home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 February / EnigmA AMIGA RUN 04 (1996)(G.R. Edizioni)(IT)[!][issue 1996-02][Skylink CD III].iso / earcd / comm2 / termsorc.lha / Extras / Source / term-source.lha / termARexxCommands.c < prev    next >
C/C++ Source or Header  |  1995-09-26  |  99KB  |  5,786 lines
  1. /*
  2. **    termARexxCommands.c
  3. **
  4. **    ARexx interface command support routines
  5. **
  6. **    Copyright © 1990-1995 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termARexxGlobal.h"
  11.  
  12.     /* Number of bytes already processed by ScanNodeFilter(). */
  13.  
  14. STATIC LONG WaitCount = 0;
  15.  
  16.     /* Cheapo shortcuts ;-) */
  17.  
  18. #define Args    Pkt -> Array
  19. #define Results    Pkt -> Results
  20.  
  21.     /* ScanNodeFilter():
  22.      *
  23.      *    Scan memory for a certain sequence.
  24.      */
  25.  
  26. STATIC STRPTR __regargs
  27. ScanNodeFilter(register STRPTR Data,register LONG Size,register struct WaitNode *Node,LONG *Position)
  28. {
  29.     register UBYTE c,Mask;
  30.  
  31.     *Position = 0;
  32.  
  33.     if(Config -> SerialConfig -> StripBit8)
  34.         Mask = 0x7F;
  35.     else
  36.         Mask = 0xFF;
  37.  
  38.     if(Node)
  39.     {
  40.         do
  41.         {
  42.             (*Position)++;
  43.  
  44.             if(c = ToUpper((*Data++) & Mask))
  45.             {
  46.                 register BYTE MatchMade;
  47.  
  48.                 do
  49.                 {
  50.                     MatchMade = FALSE;
  51.  
  52.                     if(Node -> Count == WaitCount)
  53.                     {
  54.                         if(c == (Node -> Node . ln_Name[WaitCount] & Mask))
  55.                         {
  56.                             MatchMade = TRUE;
  57.  
  58.                             if(!Node -> Node . ln_Name[++Node -> Count])
  59.                             {
  60.                                 if(Node -> ResponseLen)
  61.                                 {
  62.                                     SerWriteVerbatim(Node -> Response,Node -> ResponseLen,FALSE);
  63.  
  64.                                     Node -> Count = 0;
  65.                                 }
  66.                                 else
  67.                                     return(Node -> Node . ln_Name);
  68.                             }
  69.                         }
  70.                     }
  71.  
  72.                     if(MatchMade)
  73.                         WaitCount++;
  74.                     else
  75.                     {
  76.                         if(WaitCount)
  77.                         {
  78.                             WaitCount = 0;
  79.  
  80.                             Node -> Count = 0;
  81.                         }
  82.                         else
  83.                             break;
  84.                     }
  85.                 }
  86.                 while(!WaitCount);
  87.             }
  88.         }
  89.         while(--Size);
  90.     }
  91.     else
  92.     {
  93.         do
  94.         {
  95.             (*Position)++;
  96.  
  97.             if(c = ToUpper((*Data++) & Mask))
  98.             {
  99.                 register BYTE MatchMade;
  100.  
  101.                 do
  102.                 {
  103.                     MatchMade = FALSE;
  104.  
  105.                     Node = (struct WaitNode *)GenericListTable[GLIST_WAIT] -> ListHeader . mlh_Head;
  106.  
  107.                     while(Node -> Node . ln_Succ)
  108.                     {
  109.                         if(Node -> Count == WaitCount)
  110.                         {
  111.                             if(c == (Node -> Node . ln_Name[WaitCount] & Mask))
  112.                             {
  113.                                 Node -> Count++;
  114.  
  115.                                 MatchMade = TRUE;
  116.  
  117.                                 if(!Node -> Node . ln_Name[Node -> Count])
  118.                                 {
  119.                                     if(Node -> ResponseLen)
  120.                                     {
  121.                                         SerWriteVerbatim(Node -> Response,Node -> ResponseLen,FALSE);
  122.  
  123.                                         Node -> Count = 0;
  124.                                     }
  125.                                     else
  126.                                         return(Node -> Node . ln_Name);
  127.                                 }
  128.                             }
  129.                         }
  130.  
  131.                         Node = (struct WaitNode *)Node -> Node . ln_Succ;
  132.                     }
  133.  
  134.                     if(MatchMade)
  135.                         WaitCount++;
  136.                     else
  137.                     {
  138.                         if(WaitCount)
  139.                         {
  140.                             WaitCount = 0;
  141.  
  142.                             Node = (struct WaitNode *)GenericListTable[GLIST_WAIT] -> ListHeader . mlh_Head;
  143.  
  144.                             while(Node -> Node . ln_Succ)
  145.                             {
  146.                                 Node -> Count = 0;
  147.  
  148.                                 Node = (struct WaitNode *)Node -> Node . ln_Succ;
  149.                             }
  150.                         }
  151.                         else
  152.                             break;
  153.                     }
  154.                 }
  155.                 while(!WaitCount);
  156.             }
  157.         }
  158.         while(--Size);
  159.     }
  160.  
  161.     return(NULL);
  162. }
  163.  
  164. STRPTR
  165. RexxActivate(struct RexxPkt *Pkt)
  166. {
  167.     if(Window)
  168.         BumpWindow(Window);
  169.     else
  170.         Signal(ThisProcess,SIGBREAKF_CTRL_F);
  171.  
  172.     return(NULL);
  173. }
  174.  
  175. STRPTR
  176. RexxAdd(struct RexxPkt *Pkt)
  177. {
  178.     enum    {    ARG_ADD_FROM,ARG_ADD_BEFORE,ARG_ADD_AFTER,ARG_ADD_RESPONSE,
  179.             ARG_ADD_COMMAND,ARG_ADD_PHONEENTRY,ARG_ADD_NAME };
  180.  
  181.     WORD ListIndex;
  182.  
  183.     if((ListIndex = ToList(Args[ARG_ADD_FROM])) != -1)
  184.     {
  185.         struct GenericList    *List = GenericListTable[ListIndex];
  186.         BYTE             AddMode;
  187.  
  188.         if(Args[ARG_ADD_BEFORE])
  189.             AddMode = ADD_GLIST_BEFORE;
  190.         else
  191.         {
  192.             if(Args[ARG_ADD_AFTER])
  193.                 AddMode = ADD_GLIST_BEHIND;
  194.             else
  195.                 AddMode = ADD_GLIST_BOTTOM;
  196.         }
  197.  
  198.         if(ListIndex == GLIST_DIAL)
  199.         {
  200.             if(Args[ARG_ADD_PHONEENTRY])
  201.             {
  202.                 if(!IsNumeric(Args[ARG_ADD_PHONEENTRY]))
  203.                 {
  204.                     STRPTR Buffer;
  205.  
  206.                     if(Buffer = CreateMatchBuffer(Args[ARG_ADD_PHONEENTRY]))
  207.                     {
  208.                         struct DialNode    *Node;
  209.                         LONG         i;
  210.                         BOOL         GotIt = FALSE;
  211.  
  212.                         for(i = 0 ; i < NumPhoneEntries ; i++)
  213.                         {
  214.                             if(MatchBuffer(Buffer,Phonebook[i] -> Header -> Name))
  215.                             {
  216.                                 if(Node = (struct DialNode *)CreateGenericListNode(sizeof(struct DialNode),""))
  217.                                 {
  218.                                     Node -> Entry = Phonebook[i];
  219.  
  220.                                     AddGenericListNode(List,(struct Node *)Node,AddMode);
  221.  
  222.                                     GotIt = TRUE;
  223.                                 }
  224.                                 else
  225.                                 {
  226.                                     Results[0] = RC_ERROR;
  227.                                     Results[1] = ERROR_NO_FREE_STORE;
  228.  
  229.                                     break;
  230.                                 }
  231.                             }
  232.                         }
  233.  
  234.                         if(!GotIt && Results[0] != RC_ERROR)
  235.                         {
  236.                             Results[0] = RC_ERROR;
  237.                             Results[1] = ERROR_OBJECT_NOT_FOUND;
  238.                         }
  239.  
  240.                         DeleteMatchBuffer(Buffer);
  241.                     }
  242.                     else
  243.                     {
  244.                         Results[0] = RC_ERROR;
  245.                         Results[1] = ERROR_NO_FREE_STORE;
  246.                     }
  247.                 }
  248.                 else
  249.                 {
  250.                     LONG Index = Atol(Args[ARG_ADD_PHONEENTRY]);
  251.  
  252.                     if(Index < 0 || Index > NumPhoneEntries)
  253.                     {
  254.                         Results[0] = RC_ERROR;
  255.                         Results[1] = TERMERROR_INDEX_OUT_OF_RANGE;
  256.                     }
  257.                     else
  258.                     {
  259.                         struct DialNode    *Node;
  260.  
  261.                         if(Node = (struct DialNode *)CreateGenericListNode(sizeof(struct DialNode),""))
  262.                         {
  263.                             Node -> Entry = Phonebook[Index];
  264.  
  265.                             AddGenericListNode(List,(struct Node *)Node,AddMode);
  266.                         }
  267.                         else
  268.                         {
  269.                             Results[0] = RC_ERROR;
  270.                             Results[1] = ERROR_NO_FREE_STORE;
  271.                         }
  272.                     }
  273.                 }
  274.             }
  275.             else
  276.             {
  277.                 if(Args[ARG_ADD_NAME])
  278.                 {
  279.                     struct Node *Node;
  280.  
  281.                     if(Node = CreateGenericListNode(sizeof(struct DialNode),Args[ARG_ADD_NAME]))
  282.                         AddGenericListNode(List,Node,AddMode);
  283.                     else
  284.                     {
  285.                         Results[0] = RC_ERROR;
  286.                         Results[1] = ERROR_NO_FREE_STORE;
  287.                     }
  288.                 }
  289.             }
  290.         }
  291.         else
  292.         {
  293.             if(ListIndex == GLIST_WAIT)
  294.             {
  295.                 STRPTR    Response;
  296.                 LONG    ResponseLen;
  297.  
  298.                 if(Args[ARG_ADD_RESPONSE])
  299.                 {
  300.                     Response    = Args[ARG_ADD_RESPONSE];
  301.                     ResponseLen    = strlen(Response);
  302.                 }
  303.                 else
  304.                 {
  305.                     Response    = NULL;
  306.                     ResponseLen    = 0;
  307.                 }
  308.  
  309.                 if(Args[ARG_ADD_NAME])
  310.                 {
  311.                     struct WaitNode *Node;
  312.  
  313.                     if(Node = (struct WaitNode *)CreateGenericListNode(sizeof(struct WaitNode) + ResponseLen + 1,Args[ARG_ADD_NAME]))
  314.                     {
  315.                         WORD i,Len;
  316.  
  317.                         Len = TranslateString(Node -> Node . ln_Name,Node -> Node . ln_Name);
  318.  
  319.                         Node -> Node . ln_Name[Len] = 0;
  320.  
  321.                         for(i = 0 ; i < Len ; i++)
  322.                             Node -> Node . ln_Name[i] = ToUpper(Node -> Node . ln_Name[i]);
  323.  
  324.                         if(Response && ResponseLen)
  325.                         {
  326.                             Node -> Response = &Node -> Node . ln_Name[Len + 1];
  327.  
  328.                             strcpy(Node -> Response,Response);
  329.  
  330.                             Node -> ResponseLen = TranslateString(Node -> Response,Node -> Response);
  331.                         }
  332.                         else
  333.                             Node -> ResponseLen = 0;
  334.  
  335.                         AddGenericListNode(List,Node,AddMode);
  336.                     }
  337.                     else
  338.                     {
  339.                         Results[0] = RC_ERROR;
  340.                         Results[1] = ERROR_NO_FREE_STORE;
  341.                     }
  342.                 }
  343.                 else
  344.                 {
  345.                     Results[0] = RC_ERROR;
  346.                     Results[1] = ERROR_REQUIRED_ARG_MISSING;
  347.                 }
  348.             }
  349.             else
  350.             {
  351.                 if(ListIndex == GLIST_TRAP)
  352.                 {
  353.                     if(!Args[ARG_ADD_NAME] || !Args[ARG_ADD_COMMAND])
  354.                     {
  355.                         struct TrapNode    *Node;
  356.                         UBYTE         LocalBuffer[MAX_FILENAME_LENGTH];
  357.                         LONG         NameLen;
  358.  
  359.                         if(strlen(Args[ARG_ADD_NAME]) > 255)
  360.                             Args[ARG_ADD_NAME][255] = 0;
  361.  
  362.                         NameLen = TranslateString(Args[ARG_ADD_NAME],LocalBuffer);
  363.  
  364.                         if(Node = (struct TrapNode *)AllocVecPooled(sizeof(struct TrapNode) + strlen(Args[ARG_ADD_NAME]) + 1 + NameLen + strlen(Args[ARG_ADD_COMMAND]) + 1,MEMF_ANY))
  365.                         {
  366.                             STRPTR String = Node -> Node . ln_Name = (STRPTR)(Node + 1);
  367.  
  368.                             strcpy(String,Args[ARG_ADD_NAME]);
  369.  
  370.                             String += strlen(String) + 1;
  371.  
  372.                             Node -> Sequence = String;
  373.  
  374.                             CopyMem(LocalBuffer,String,NameLen);
  375.  
  376.                             String += NameLen;
  377.  
  378.                             Node -> Command = String;
  379.  
  380.                             strcpy(String,Args[ARG_ADD_COMMAND]);
  381.  
  382.                             Node -> SequenceLen = NameLen;
  383.                             Node -> Count = 0;
  384.  
  385.                             AddGenericListNode(List,Node,AddMode);
  386.                         }
  387.                         else
  388.                         {
  389.                             Results[0] = RC_ERROR;
  390.                             Results[1] = ERROR_NO_FREE_STORE;
  391.                         }
  392.                     }
  393.                     else
  394.                     {
  395.                         Results[0] = RC_ERROR;
  396.                         Results[1] = ERROR_REQUIRED_ARG_MISSING;
  397.                     }
  398.                 }
  399.                 else
  400.                 {
  401.                     if(Args[ARG_ADD_NAME])
  402.                     {
  403.                         struct Node *Node;
  404.  
  405.                         if(Node = CreateGenericListNode(sizeof(struct DialNode),Args[ARG_ADD_NAME]))
  406.                             AddGenericListNode(List,Node,AddMode);
  407.                         else
  408.                         {
  409.                             Results[0] = RC_ERROR;
  410.                             Results[1] = ERROR_NO_FREE_STORE;
  411.                         }
  412.                     }
  413.                     else
  414.                     {
  415.                         Results[0] = RC_ERROR;
  416.                         Results[1] = TERMERROR_WRONG_LIST;
  417.                     }
  418.                 }
  419.             }
  420.         }
  421.     }
  422.     else
  423.     {
  424.         Results[0] = RC_ERROR;
  425.         Results[1] = TERMERROR_UNKNOWN_LIST;
  426.     }
  427.  
  428.     return(NULL);
  429. }
  430.  
  431. STRPTR
  432. RexxBaud(struct RexxPkt *Pkt)
  433. {
  434.     enum    {    ARG_BAUD_RATE };
  435.  
  436.     LONG Rate = *(LONG *)Args[ARG_BAUD_RATE],Min = MILLION,Diff,Index;
  437.     WORD i;
  438.  
  439.     for(i = 0 ; i < NumBaudRates ; i++)
  440.     {
  441.         Diff = Rate - BaudRates[i];
  442.  
  443.         if(Diff >= 0 && Diff < Min)
  444.         {
  445.             Min    = Diff;
  446.             Index    = i;
  447.         }
  448.     }
  449.  
  450.     if(BaudRates[Index] != Config -> SerialConfig -> BaudRate)
  451.     {
  452.         Config -> SerialConfig -> BaudRate = BaudRates[Index];
  453.  
  454.         ConfigChanged = TRUE;
  455.  
  456.         UpdateRequired = TRUE;
  457.     }
  458.  
  459.     return(NULL);
  460. }
  461.  
  462. STRPTR
  463. RexxBeepScreen(struct RexxPkt *Pkt)
  464. {
  465.     BellSignal();
  466.  
  467.     return(NULL);
  468. }
  469.  
  470. STRPTR
  471. RexxCallMenu(struct RexxPkt *Pkt)
  472. {
  473.     enum    {    ARG_CALLMENU_TITLE };
  474.  
  475.     STRPTR Buffer;
  476.  
  477.     if(Buffer = CreateMatchBuffer(Args[ARG_CALLMENU_TITLE]))
  478.     {
  479.         WORD i;
  480.  
  481.         Results[0] = RC_WARN;
  482.  
  483.             /* Scan the menu list... */
  484.  
  485.         for(i = 0 ; TermMenu[i] . nm_Type != NM_END ; i++)
  486.         {
  487.                 /* Did we get a valid name string? */
  488.  
  489.             if(TermMenu[i] . nm_Label != NM_BARLABEL)
  490.             {
  491.                     /* Does the name match our template? */
  492.  
  493.                 if(MatchBuffer(Buffer,TermMenu[i] . nm_Label))
  494.                 {
  495.                     HandleMenuCode((ULONG)TermMenu[i] . nm_UserData,NULL);
  496.  
  497.                     Results[0] = RC_OK;
  498.  
  499.                     break;
  500.                 }
  501.             }
  502.         }
  503.  
  504.         DeleteMatchBuffer(Buffer);
  505.     }
  506.     else
  507.     {
  508.         Results[0] = RC_ERROR;
  509.         Results[1] = ERROR_NO_FREE_STORE;
  510.     }
  511.  
  512.     return(NULL);
  513. }
  514.  
  515. STRPTR
  516. RexxCapture(struct RexxPkt *Pkt)
  517. {
  518.     enum    {    ARG_CAPTURE_TO,ARG_CAPTURE_NAME };
  519.  
  520.     if(!Stricmp(Args[ARG_CAPTURE_TO],"PRINTER"))
  521.     {
  522.         if(!PrinterCapture)
  523.             OpenPrinterCapture(FALSE);
  524.     }
  525.     else
  526.     {
  527.         if(!Stricmp(Args[ARG_CAPTURE_TO],"FILE"))
  528.         {
  529.             if(FileCapture)
  530.             {
  531.                 Results[0] = RC_ERROR;
  532.                 Results[1] = ERROR_OBJECT_IN_USE;
  533.             }
  534.             else
  535.             {
  536.                 if(Args[ARG_CAPTURE_NAME])
  537.                 {
  538.                     if(FileCapture = BufferOpen(Args[ARG_CAPTURE_NAME],"a"))
  539.                         strcpy(CaptureName,Args[ARG_CAPTURE_NAME]);
  540.                     else
  541.                     {
  542.                         Results[0] = RC_ERROR;
  543.                         Results[1] = IoErr();
  544.                     }
  545.                 }
  546.                 else
  547.                 {
  548.                     UBYTE             DummyBuffer[MAX_FILENAME_LENGTH],
  549.                                 *DummyChar;
  550.                     struct FileRequester    *FileRequest;
  551.  
  552.                     if(!CaptureName[0])
  553.                     {
  554.                         strcpy(CaptureName,Config -> CaptureConfig -> CapturePath);
  555.  
  556.                         if(!AddPart(CaptureName,LocaleString(MSG_DIALPANEL_CAPTURE_NAME_TXT),MAX_FILENAME_LENGTH))
  557.                             CaptureName[0] = 0;
  558.                     }
  559.  
  560.                     strcpy(DummyBuffer,CaptureName);
  561.  
  562.                     DummyChar = PathPart(DummyBuffer);
  563.  
  564.                     *DummyChar = 0;
  565.  
  566.                     BlockWindows();
  567.  
  568.                     if(FileRequest = GetFile(Window,LocaleString(MSG_TERMMAIN_CAPTURE_TO_DISK_TXT),DummyBuffer,FilePart(CaptureName),DummyBuffer,NULL,TRUE,FALSE,FALSE,LocaleString(MSG_GLOBAL_OPEN_TXT),FALSE))
  569.                     {
  570.                         BYTE Continue;
  571.  
  572.                         if(GetFileSize(DummyBuffer))
  573.                         {
  574.                             Continue = TRUE;
  575.  
  576.                             switch(MyEasyRequest(Window,LocaleString(MSG_GLOBAL_FILE_ALREADY_EXISTS_TXT),LocaleString(MSG_GLOBAL_CREATE_APPEND_CANCEL_TXT),DummyBuffer))
  577.                             {
  578.                                 case 1:
  579.  
  580.                                     FileCapture = BufferOpen(DummyBuffer,"w");
  581.                                     break;
  582.  
  583.                                 case 2:
  584.  
  585.                                     FileCapture = BufferOpen(DummyBuffer,"a");
  586.                                     break;
  587.  
  588.                                 case 0:
  589.  
  590.                                     Results[0] = RC_WARN;
  591.                                     Continue = FALSE;
  592.                                     break;
  593.                             }
  594.                         }
  595.                         else
  596.                         {
  597.                             Continue = TRUE;
  598.  
  599.                             FileCapture = BufferOpen(DummyBuffer,"w");
  600.                         }
  601.  
  602.                         if(Continue)
  603.                         {
  604.                             if(!FileCapture)
  605.                             {
  606.                                 MyEasyRequest(Window,LocaleString(MSG_GLOBAL_ERROR_OPENING_FILE_TXT),LocaleString(MSG_GLOBAL_CONTINUE_TXT),DummyBuffer);
  607.  
  608.                                 Results[0] = RC_ERROR;
  609.                                 Results[1] = IoErr();
  610.                             }
  611.                             else
  612.                             {
  613.                                 strcpy(CaptureName,DummyBuffer);
  614.  
  615.                                 CheckItem(MEN_CAPTURE_TO_FILE,TRUE);
  616.                             }
  617.                         }
  618.  
  619.                         FreeAslRequest(FileRequest);
  620.                     }
  621.  
  622.                     ReleaseWindows();
  623.                 }
  624.             }
  625.         }
  626.         else
  627.         {
  628.             Results[0] = RC_ERROR;
  629.             Results[1] = ERROR_REQUIRED_ARG_MISSING;
  630.         }
  631.     }
  632.  
  633.     ConOutputUpdate();
  634.  
  635.     Forbid();
  636.  
  637.     CheckItem(MEN_CAPTURE_TO_FILE,        FileCapture != NULL);
  638.     CheckItem(MEN_CAPTURE_TO_PRINTER,    PrinterCapture != NULL);
  639.  
  640.     Permit();
  641.  
  642.     return(NULL);
  643. }
  644.  
  645. STRPTR
  646. RexxClear(struct RexxPkt *Pkt)
  647. {
  648.     enum    {    ARG_CLEAR_FROM,ARG_CLEAR_FORCE };
  649.  
  650.     if(!Stricmp(Args[ARG_CLEAR_FROM],"BUFFER"))
  651.     {
  652.         if(Lines)
  653.         {
  654.             if(Args[ARG_CLEAR_FORCE])
  655.             {
  656.                 FreeBuffer();
  657.  
  658.                 TerminateBuffer();
  659.             }
  660.             else
  661.             {
  662.                 BlockWindows();
  663.  
  664.                 if(MyEasyRequest(Window,LocaleString(MSG_TERMMAIN_BUFFER_STILL_HOLDS_LINES_TXT),LocaleString(MSG_GLOBAL_YES_NO_TXT),Lines))
  665.                 {
  666.                     FreeBuffer();
  667.  
  668.                     TerminateBuffer();
  669.                 }
  670.                 else
  671.                     Results[0] = RC_WARN;
  672.  
  673.                 ReleaseWindows();
  674.             }
  675.         }
  676.     }
  677.     else
  678.     {
  679.         WORD ListIndex;
  680.  
  681.         if((ListIndex = ToList(Args[ARG_CLEAR_FROM])) != -1)
  682.             ClearGenericList(GenericListTable[ListIndex]);
  683.         else
  684.         {
  685.             Results[0] = RC_ERROR;
  686.             Results[1] = TERMERROR_UNKNOWN_LIST;
  687.         }
  688.     }
  689.  
  690.     return(NULL);
  691. }
  692.  
  693. STRPTR
  694. RexxClearScreen(struct RexxPkt *Pkt)
  695. {
  696.     if(XEmulatorBase && Config -> TerminalConfig -> EmulationMode == EMULATION_EXTERNAL)
  697.         XEmulatorClearConsole(XEM_IO);
  698.     else
  699.     {
  700.         DropMarker();
  701.  
  702.         ConBypass("\033[2J\033[H",-1);
  703.     }
  704.  
  705.     return(NULL);
  706. }
  707.  
  708. STRPTR
  709. RexxClose(struct RexxPkt *Pkt)
  710. {
  711.     enum    {    ARG_CLOSE_FROM };
  712.  
  713.     STATIC STRPTR ValidArgs[3] =
  714.     {
  715.         "PRINTER",
  716.         "FILE",
  717.         "ALL"
  718.     };
  719.  
  720.     WORD i;
  721.  
  722.     for(i = 0 ; i < 3 ; i++)
  723.     {
  724.         if(!Stricmp(Args[ARG_CLOSE_FROM],ValidArgs[i]))
  725.         {
  726.             if(i == 0 || i == 2)
  727.             {
  728.                 if(PrinterCapture)
  729.                     ClosePrinterCapture(TRUE);
  730.             }
  731.  
  732.             if(i == 1 || i == 2)
  733.             {
  734.                 if(FileCapture)
  735.                 {
  736.                     BufferClose(FileCapture);
  737.  
  738.                     CheckItem(MEN_CAPTURE_TO_FILE,FALSE);
  739.  
  740.                     FileCapture = NULL;
  741.  
  742.                     if(!GetFileSize(CaptureName))
  743.                         DeleteFile(CaptureName);
  744.                     else
  745.                     {
  746.                         AddProtection(CaptureName,FIBF_EXECUTE);
  747.  
  748.                         if(Config -> MiscConfig -> CreateIcons)
  749.                             AddIcon(CaptureName,FILETYPE_TEXT,TRUE);
  750.                     }
  751.  
  752.                     ConOutputUpdate();
  753.                 }
  754.             }
  755.  
  756.             return(NULL);
  757.         }
  758.     }
  759.  
  760.     Results[0] = RC_ERROR;
  761.     Results[1] = ERROR_TOO_MANY_ARGS;
  762.  
  763.     return(NULL);
  764. }
  765.  
  766. STRPTR
  767. RexxCloseDevice(struct RexxPkt *Pkt)
  768. {
  769.     ClearSerial();
  770.  
  771.     DeleteSerial();
  772.  
  773.     return(NULL);
  774. }
  775.  
  776. STRPTR
  777. RexxCloseRequester(struct RexxPkt *Pkt)
  778. {
  779.     if(ThisProcess)
  780.         Signal(ThisProcess,SIG_BREAK);
  781.     else
  782.         Results[0] = RC_WARN;
  783.  
  784.     return(NULL);
  785. }
  786.  
  787. STRPTR
  788. RexxDeactivate(struct RexxPkt *Pkt)
  789. {
  790.     Forbid();
  791.  
  792.     if(Window)
  793.         DoIconify = TRUE;
  794.  
  795.     Permit();
  796.  
  797.     return(NULL);
  798. }
  799.  
  800. STRPTR
  801. RexxDial(struct RexxPkt *Pkt)
  802. {
  803.     enum    {    ARG_SYNC,ARG_DIAL_NUM };
  804.  
  805.     struct PhoneNode    *DialNode;
  806.     struct GenericList    *List;
  807.  
  808.     if(Args[ARG_DIAL_NUM])
  809.     {
  810.         struct List *LocalList;
  811.  
  812.         if(LocalList = (struct List *)AllocVecPooled(sizeof(struct List),MEMF_ANY))
  813.         {
  814.             LONG Len = strlen(Args[ARG_DIAL_NUM]);
  815.  
  816.             NewList(LocalList);
  817.  
  818.             if(DialNode = (struct PhoneNode *)AllocVecPooled(sizeof(struct PhoneNode) + Len + 1,MEMF_ANY | MEMF_CLEAR))
  819.             {
  820.                 DialNode -> VanillaNode . ln_Name = (STRPTR)(DialNode + 1);
  821.  
  822.                 strcpy(DialNode -> VanillaNode . ln_Name,Args[ARG_DIAL_NUM]);
  823.  
  824.                 AddTail(LocalList,&DialNode -> VanillaNode);
  825.  
  826.                 FreeDialList(TRUE);
  827.  
  828.                 DialList = LocalList;
  829.             }
  830.             else
  831.             {
  832.                 FreeVecPooled(LocalList);
  833.  
  834.                 Results[0] = RC_ERROR;
  835.                 Results[1] = ERROR_NO_FREE_STORE;
  836.  
  837.                 return(NULL);
  838.             }
  839.         }
  840.     }
  841.     else
  842.     {
  843.         if(GenericListCount(List = GenericListTable[GLIST_DIAL]))
  844.         {
  845.             struct DialNode *Node = (struct DialNode *)FirstGenericListNode(List);
  846.  
  847.             if(Node)
  848.             {
  849.                 LONG Len;
  850.  
  851.                 if(!DialList)
  852.                 {
  853.                     if(DialList = (struct List *)AllocVecPooled(sizeof(struct List),MEMF_ANY | MEMF_CLEAR))
  854.                         NewList(DialList);
  855.                 }
  856.  
  857.                 if(DialList)
  858.                 {
  859.                     while(Node)
  860.                     {
  861.                         if(Node -> Entry)
  862.                             Len = 0;
  863.                         else
  864.                             Len = strlen(Node -> Node . ln_Name) + 1;
  865.  
  866.                         if(DialNode = (struct PhoneNode *)AllocVecPooled(sizeof(struct PhoneNode) + Len,MEMF_ANY | MEMF_CLEAR))
  867.                         {
  868.                             if(Node -> Entry)
  869.                                 DialNode -> Entry = Node -> Entry;
  870.                             else
  871.                             {
  872.                                 DialNode -> VanillaNode . ln_Name = (STRPTR)(DialNode + 1);
  873.  
  874.                                 strcpy(DialNode -> VanillaNode . ln_Name,Node -> Node . ln_Name);
  875.                             }
  876.  
  877.                             AddTail(DialList,&DialNode -> VanillaNode);
  878.                         }
  879.                         else
  880.                         {
  881.                             FreeDialList(FALSE);
  882.  
  883.                             Results[0] = RC_ERROR;
  884.                             Results[1] = ERROR_NO_FREE_STORE;
  885.  
  886.                             return(NULL);
  887.                         }
  888.  
  889.                         Node = (struct DialNode *)NextGenericListNode(List);
  890.                     }
  891.                 }
  892.             }
  893.         }
  894.     }
  895.  
  896.     if(DialList)
  897.     {
  898.         if(DialList -> lh_Head -> ln_Succ)
  899.         {
  900.             DoDial = DIAL_LIST;
  901.  
  902.             Forbid();
  903.  
  904.             if(!DialMsg && Args[ARG_SYNC])
  905.             {
  906.                 DialMsg = Pkt -> RexxMsg;
  907.  
  908.                 Pkt -> RexxMsg = NULL;
  909.             }
  910.  
  911.             Permit();
  912.         }
  913.         else
  914.         {
  915.             FreeDialList(FALSE);
  916.  
  917.             Results[0] = RC_ERROR;
  918.             Results[1] = TERMERROR_LIST_IS_ALREADY_EMPTY;
  919.         }
  920.     }
  921.     else
  922.     {
  923.         Results[0] = RC_ERROR;
  924.         Results[1] = ERROR_NO_FREE_STORE;
  925.     }
  926.  
  927.     return(NULL);
  928. }
  929.  
  930. STRPTR
  931. RexxDelay(struct RexxPkt *Pkt)
  932. {
  933.     enum    {    ARG_DELAY_MICROSECONDS,ARG_DELAY_SECONDS,ARG_DELAY_MINUTES,ARG_DELAY_QUIET };
  934.  
  935.     LONG    Seconds = 0,
  936.         Micros;
  937.     ULONG    Signals;
  938.     BYTE    Quiet;
  939.  
  940.     if(Args[ARG_DELAY_QUIET] || !ReadRequest || !WriteRequest)
  941.         Quiet = TRUE;
  942.     else
  943.         Quiet = FALSE;
  944.  
  945.     if(Args[ARG_DELAY_MINUTES])
  946.         Seconds += 60 * (*(LONG *)Args[ARG_DELAY_MINUTES]);
  947.  
  948.     if(Args[ARG_DELAY_SECONDS])
  949.         Seconds += *(LONG *)Args[ARG_DELAY_SECONDS];
  950.  
  951.     if(Args[ARG_DELAY_MICROSECONDS])
  952.         Micros = *(LONG *)Args[ARG_DELAY_MICROSECONDS];
  953.     else
  954.         Micros = 0;
  955.  
  956.     if(Seconds || Micros)
  957.     {
  958.         StartTime(Seconds,Micros);
  959.  
  960.         BlockWindows();
  961.  
  962.         if(Marking)
  963.             DropMarker();
  964.  
  965.         if(Quiet)
  966.             Signals = NULL;
  967.         else
  968.         {
  969.             if(DataHold)
  970.             {
  971.                 ConProcess(DataHold,DataSize);
  972.  
  973.                 Status = STATUS_READY;
  974.  
  975.                 DataHold = NULL;
  976.  
  977.                 RestartSerial();
  978.             }
  979.  
  980.             Signals = CheckSignal(SIG_SERIAL);
  981.         }
  982.  
  983.         FOREVER
  984.         {
  985.             if(Signals & SIG_SERIAL)
  986.             {
  987.                 if(!WaitSerialRead())
  988.                 {
  989.                     LONG Length;
  990.  
  991.                     BytesIn++;
  992.  
  993.                     if(Translate_CR_LF)
  994.                         Length = (* Translate_CR_LF)(ReadBuffer,1);
  995.                     else
  996.                         Length = 1;
  997.  
  998.                     if(Length)
  999.                     {
  1000.                         ConProcess(ReadBuffer,Length);
  1001.  
  1002.                         Status = STATUS_READY;
  1003.                     }
  1004.  
  1005.                         /* Check how many bytes are still in
  1006.                          * the serial buffer.
  1007.                          */
  1008.  
  1009.                     if(Length = GetSerialWaiting())
  1010.                     {
  1011.                         if(Length > SerialBufferSize)
  1012.                             Length = SerialBufferSize;
  1013.  
  1014.                         if(Length > Config -> SerialConfig -> Quantum)
  1015.                             Length = Config -> SerialConfig -> Quantum;
  1016.  
  1017.                         if(!DoSerialRead(ReadBuffer,Length))
  1018.                         {
  1019.                             BytesIn += Length;
  1020.  
  1021.                             if(Translate_CR_LF)
  1022.                                 Length = (* Translate_CR_LF)(ReadBuffer,Length);
  1023.  
  1024.                                 /* Send the data to the console. */
  1025.  
  1026.                             if(Length)
  1027.                                 ConProcess(ReadBuffer,Length);
  1028.  
  1029.                             Status = STATUS_READY;
  1030.                         }
  1031.                     }
  1032.                 }
  1033.  
  1034.                 RestartSerial();
  1035.             }
  1036.  
  1037.             if(Signals & SIG_BREAK)
  1038.             {
  1039.                 StopTime();
  1040.  
  1041.                 Results[0] = RC_WARN;
  1042.  
  1043.                 break;
  1044.             }
  1045.  
  1046.             if(Signals & SIG_TIMER)
  1047.             {
  1048.                 WaitIO(TimeRequest);
  1049.  
  1050.                 break;
  1051.             }
  1052.  
  1053.             if(Quiet)
  1054.                 Signals = Wait(SIG_TIMER | SIG_BREAK);
  1055.             else
  1056.                 Signals = Wait(SIG_TIMER | SIG_BREAK | SIG_SERIAL);
  1057.         }
  1058.  
  1059.         ReleaseWindows();
  1060.     }
  1061.  
  1062.     return(NULL);
  1063. }
  1064.  
  1065. STRPTR
  1066. RexxDuplex(struct RexxPkt *Pkt)
  1067. {
  1068.     enum    {    ARG_DUPLEX_FULL,ARG_DUPLEX_HALF };
  1069.  
  1070.     BYTE Mode;
  1071.  
  1072.     if(Args[ARG_DUPLEX_FULL])
  1073.         Mode = DUPLEX_FULL;
  1074.  
  1075.     if(Args[ARG_DUPLEX_HALF])
  1076.         Mode = DUPLEX_HALF;
  1077.  
  1078.     if(Config -> SerialConfig -> Duplex != Mode)
  1079.     {
  1080.         Config -> SerialConfig -> Duplex = Mode;
  1081.  
  1082.         UpdateRequired = TRUE;
  1083.  
  1084.         ConfigChanged = TRUE;
  1085.     }
  1086.  
  1087.     return(NULL);
  1088. }
  1089.  
  1090. STRPTR
  1091. RexxFault(struct RexxPkt *Pkt)
  1092. {
  1093.     enum    {    ARG_FAULT_CODE };
  1094.  
  1095.     LONG    Code = *(LONG *)Args[ARG_FAULT_CODE];
  1096.     UBYTE    RexxResultString[MAX_FILENAME_LENGTH];
  1097.     STRPTR    Result;
  1098.  
  1099.     if(Code >= ERR10_001 && Code <= ERR10_048)
  1100.         Result = LocaleString(MSG_AREXX_SYSERR10_001_TXT + Code - ERR10_001);
  1101.     else
  1102.     {
  1103.         if(Code >= TERMERROR_NO_DATA_TO_PROCESS && Code <= TERMERROR_WRONG_LIST)
  1104.             Result = LocaleString(MSG_AREXX_HOSTERR_000_TXT + Code - TERMERROR_NO_DATA_TO_PROCESS);
  1105.         else
  1106.         {
  1107.             Fault(Code,"",RexxResultString,MAX_FILENAME_LENGTH);
  1108.  
  1109.             Result = &RexxResultString[2];
  1110.         }
  1111.     }
  1112.  
  1113.     return(CreateResult(Result,Results));
  1114. }
  1115.  
  1116. STRPTR
  1117. RexxGetClip(struct RexxPkt *Pkt)
  1118. {
  1119.     enum    {    ARG_GETCLIP_UNIT };
  1120.  
  1121.     struct IFFHandle    *Handle;
  1122.     STRPTR             ResultBuffer = NULL;
  1123.  
  1124.     if(Handle = AllocIFF())
  1125.     {
  1126.         if(Args[ARG_GETCLIP_UNIT])
  1127.             Handle -> iff_Stream = (ULONG)OpenClipboard(*(LONG *)Args[ARG_GETCLIP_UNIT]);
  1128.         else
  1129.             Handle -> iff_Stream = (ULONG)OpenClipboard(Config -> ClipConfig -> ClipboardUnit);
  1130.  
  1131.         if(Handle -> iff_Stream)
  1132.         {
  1133.             InitIFFasClip(Handle);
  1134.  
  1135.             if(!OpenIFF(Handle,IFFF_READ))
  1136.             {
  1137.                 if(!StopChunk(Handle,ID_FTXT,ID_CHRS))
  1138.                 {
  1139.                     if(!ParseIFF(Handle,IFFPARSE_SCAN))
  1140.                     {
  1141.                         struct ContextNode *ContextNode;
  1142.  
  1143.                         ContextNode = CurrentChunk(Handle);
  1144.  
  1145.                         if(ContextNode -> cn_Type == ID_FTXT && ContextNode -> cn_Size > 0)
  1146.                         {
  1147.                             STRPTR Result;
  1148.  
  1149.                             if(Result = (STRPTR)AllocVecPooled(ContextNode -> cn_Size,MEMF_ANY))
  1150.                             {
  1151.                                 if(ReadChunkBytes(Handle,Result,ContextNode -> cn_Size) == ContextNode -> cn_Size)
  1152.                                     ResultBuffer = CreateArgstring(Result,ContextNode -> cn_Size);
  1153.  
  1154.                                 FreeVecPooled(Result);
  1155.                             }
  1156.                             else
  1157.                             {
  1158.                                 Results[0] = RC_ERROR;
  1159.                                 Results[1] = ERROR_NO_FREE_STORE;
  1160.                             }
  1161.                         }
  1162.                         else
  1163.                             Results[0] = RC_WARN;
  1164.                     }
  1165.                     else
  1166.                     {
  1167.                         Results[0] = RC_ERROR;
  1168.                         Results[1] = ERROR_OBJECT_NOT_FOUND;
  1169.                     }
  1170.                 }
  1171.                 else
  1172.                 {
  1173.                     Results[0] = RC_ERROR;
  1174.                     Results[1] = ERROR_OBJECT_NOT_FOUND;
  1175.                 }
  1176.  
  1177.                 CloseIFF(Handle);
  1178.             }
  1179.             else
  1180.             {
  1181.                 Results[0] = RC_ERROR;
  1182.                 Results[1] = ERROR_OBJECT_NOT_FOUND;
  1183.             }
  1184.  
  1185.             CloseClipboard((struct ClipboardHandle *)Handle -> iff_Stream);
  1186.         }
  1187.         else
  1188.         {
  1189.             Results[0] = RC_ERROR;
  1190.             Results[1] = TERMERROR_UNIT_NOT_AVAILABLE;
  1191.         }
  1192.  
  1193.         FreeIFF(Handle);
  1194.     }
  1195.     else
  1196.     {
  1197.         Results[0] = RC_ERROR;
  1198.         Results[1] = ERROR_OBJECT_NOT_FOUND;
  1199.     }
  1200.  
  1201.     return(ResultBuffer);
  1202. }
  1203.  
  1204. STRPTR
  1205. RexxGoOnline(struct RexxPkt *Pkt)
  1206. {
  1207.     ObtainSemaphore(&OnlineSemaphore);
  1208.  
  1209.     if(!Online)
  1210.     {
  1211.         WasOnline        = Online;
  1212.         Online            = TRUE;
  1213.  
  1214.         ReleaseSemaphore(&OnlineSemaphore);
  1215.  
  1216.         BaudCount        = 0;
  1217.         BaudBuffer[0]        = 0;
  1218.         BaudPending        = FALSE;
  1219.         CurrentPay        = 0;
  1220.  
  1221.         ObtainSemaphore(&PatternSemaphore);
  1222.  
  1223.         ChosenEntry        = NULL;
  1224.         ChosenPattern        = NULL;
  1225.  
  1226.         ReleaseSemaphore(&PatternSemaphore);
  1227.  
  1228.         Password[0]        = 0;
  1229.         UserName[0]        = 0;
  1230.         SendStartup        = FALSE;
  1231.         LimitCount        = -1;
  1232.         CurrentBBSName[0]    = 0;
  1233.         CurrentBBSComment[0]    = 0;
  1234.         CurrentBBSNumber[0]    = 0;
  1235.  
  1236.         Forbid();
  1237.  
  1238.         SetDialMenu(FALSE);
  1239.  
  1240.         Permit();
  1241.     }
  1242.     else
  1243.         ReleaseSemaphore(&OnlineSemaphore);
  1244.  
  1245.     return(NULL);
  1246. }
  1247.  
  1248. STRPTR
  1249. RexxHangup(struct RexxPkt *Pkt)
  1250. {
  1251.     if(!WriteRequest)
  1252.     {
  1253.         Results[0] = RC_WARN;
  1254.  
  1255.         return(NULL);
  1256.     }
  1257.  
  1258.     BlockWindows();
  1259.  
  1260.     HangUp();
  1261.  
  1262.         /* We are no longer online. */
  1263.  
  1264.     ObtainSemaphore(&OnlineSemaphore);
  1265.  
  1266.     if(Online)
  1267.     {
  1268.         WasOnline    = Online;
  1269.         Online        = FALSE;
  1270.     }
  1271.  
  1272.     ReleaseSemaphore(&OnlineSemaphore);
  1273.  
  1274.         /* Reset time limit. */
  1275.  
  1276.     LimitCount = -1;
  1277.  
  1278.         /* Clear the password. */
  1279.  
  1280.     Password[0]        = 0;
  1281.     UserName[0]        = 0;
  1282.  
  1283.     CurrentBBSName[0]    = 0;
  1284.     CurrentBBSComment[0]    = 0;
  1285.     CurrentBBSNumber[0]    = 0;
  1286.  
  1287.         /* Note the  last action. */
  1288.  
  1289.     LogAction(LocaleString(MSG_TERMMAIN_LOGMSG_HANG_UP_TXT));
  1290.  
  1291.     ReleaseWindows();
  1292.  
  1293.         /* Execute logoff macro. */
  1294.  
  1295.     if(WasOnline && Config -> CommandConfig -> LogoffMacro[0])
  1296.         SerialCommand(Config -> CommandConfig -> LogoffMacro);
  1297.  
  1298.         /* Update the logfile. */
  1299.  
  1300.     StopCall(FALSE);
  1301.  
  1302.         /* Don't execute the logoff macro twice. */
  1303.  
  1304.     ObtainSemaphore(&OnlineSemaphore);
  1305.  
  1306.     WasOnline = FALSE;
  1307.  
  1308.     ReleaseSemaphore(&OnlineSemaphore);
  1309.  
  1310.         /* Enable the dialing functions. */
  1311.  
  1312.     SetDialMenu(TRUE);
  1313.  
  1314.     if(Config -> ModemConfig -> RedialAfterHangup)
  1315.     {
  1316.         if(DialList)
  1317.         {
  1318.             if(DialList -> lh_Head -> ln_Succ)
  1319.                 DoDial = DIAL_REDIAL;
  1320.         }
  1321.     }
  1322.  
  1323.     ObtainSemaphore(&PatternSemaphore);
  1324.  
  1325.     ChosenEntry    = NULL;
  1326.     ChosenPattern    = NULL;
  1327.  
  1328.     ReleaseSemaphore(&PatternSemaphore);
  1329.  
  1330.     return(NULL);
  1331. }
  1332.  
  1333. STRPTR
  1334. RexxHelp(struct RexxPkt *Pkt)
  1335. {
  1336.     enum    {    ARG_HELP_COMMAND,ARG_HELP_PROMPT };
  1337.  
  1338.     if(Args[ARG_HELP_PROMPT])
  1339.         GuideSetup();
  1340.     else
  1341.     {
  1342.         WORD i;
  1343.  
  1344.         for(i = 0 ; i < CommandTableSize ; i++)
  1345.         {
  1346.             if(!Stricmp(Args[ARG_HELP_COMMAND],CommandTable[i] . Name))
  1347.             {
  1348.                 if(CommandTable[i] . Arguments)
  1349.                     return(CreateResult(CommandTable[i] . Arguments,Results));
  1350.                 else
  1351.                     return(CreateResult(",",Results));
  1352.             }
  1353.         }
  1354.  
  1355.         Results[0] = RC_ERROR;
  1356.         Results[1] = ERROR_OBJECT_NOT_FOUND;
  1357.     }
  1358.  
  1359.     return(NULL);
  1360. }
  1361.  
  1362. STRPTR
  1363. RexxOpen(struct RexxPkt *Pkt)
  1364. {
  1365.     enum    {    ARG_OPEN_NAME,ARG_OPEN_TO };
  1366.  
  1367.     WORD Index = ToConfig(Args[ARG_OPEN_TO]);
  1368.  
  1369.     if(Index == -1 || Index > DATATYPE_PHONEBOOK)
  1370.     {
  1371.         Results[0] = RC_ERROR;
  1372.         Results[1] = ERROR_OBJECT_NOT_FOUND;
  1373.     }
  1374.     else
  1375.     {
  1376.         UBYTE    DummyBuffer[MAX_FILENAME_LENGTH];
  1377.         STRPTR    FileName;
  1378.  
  1379.         if(Args[ARG_OPEN_NAME])
  1380.             FileName = Args[ARG_OPEN_NAME];
  1381.         else
  1382.         {
  1383.             STRPTR             Title;
  1384.             struct FileRequester    *FileRequest;
  1385.  
  1386.             FileName = NULL;
  1387.  
  1388.             switch(Index)
  1389.             {
  1390.                 case DATATYPE_TRANSLATIONS:
  1391.  
  1392.                     Title = LocaleString(MSG_PHONEPANEL_SELECT_TRANSLATION_TXT);
  1393.                     break;
  1394.  
  1395.                 case DATATYPE_FUNCTIONKEYS:
  1396.  
  1397.                     Title = LocaleString(MSG_PHONEPANEL_SELECT_KEYBOARD_MACROS_TXT);
  1398.                     break;
  1399.  
  1400.                 case DATATYPE_CURSORKEYS:
  1401.  
  1402.                     Title = LocaleString(MSG_PHONEPANEL_SELECT_CURSOR_KEYS_TXT);
  1403.                     break;
  1404.  
  1405.                 case DATATYPE_FASTMACROS:
  1406.  
  1407.                     Title = LocaleString(MSG_PHONEPANEL_SELECT_FAST_MACROS_TXT);
  1408.                     break;
  1409.  
  1410.                 case DATATYPE_HOTKEYS:
  1411.  
  1412.                     Title = LocaleString(MSG_HOTKEYPANEL_LOAD_HOTKEYS_TXT);
  1413.                     break;
  1414.  
  1415.                 case DATATYPE_SPEECH:
  1416.  
  1417.                     Title = LocaleString(MSG_SPEECHPANEL_LOAD_SPEECH_SETTINGS_TXT);
  1418.                     break;
  1419.  
  1420.                 case DATATYPE_SOUND:
  1421.  
  1422.                     Title = LocaleString(MSG_SOUNDPANEL_LOAD_SOUNDS_TXT);
  1423.                     break;
  1424.  
  1425.                 case DATATYPE_BUFFER:
  1426.  
  1427.                     Title = LocaleString(MSG_TERMMAIN_LOAD_BUFFER_TXT);
  1428.                     break;
  1429.  
  1430.                 case DATATYPE_CONFIGURATION:
  1431.  
  1432.                     Title = LocaleString(MSG_TERMMAIN_OPEN_PREFERENCES_TXT);
  1433.                     break;
  1434.  
  1435.                 case DATATYPE_PHONEBOOK:
  1436.  
  1437.                     Title = LocaleString(MSG_PHONEPANEL_LOAD_PHONEBOOK_TXT);
  1438.                     break;
  1439.             }
  1440.  
  1441.             BlockWindows();
  1442.  
  1443.             if(FileRequest = GetFile(Window,Title,"","",DummyBuffer,NULL,FALSE,FALSE,FALSE,"Ok",TRUE))
  1444.             {
  1445.                 FileName = DummyBuffer;
  1446.  
  1447.                 FreeAslRequest(FileRequest);
  1448.             }
  1449.             else
  1450.                 Results[0] = RC_WARN;
  1451.  
  1452.             ReleaseWindows();
  1453.         }
  1454.  
  1455.         if(FileName)
  1456.         {
  1457.             if(!GetFileSize(FileName))
  1458.             {
  1459.                 Results[0] = RC_ERROR;
  1460.                 Results[1] = ERROR_OBJECT_NOT_FOUND;
  1461.  
  1462.                 return(NULL);
  1463.             }
  1464.  
  1465.             BlockWindows();
  1466.  
  1467.             switch(Index)
  1468.             {
  1469.                 case DATATYPE_TRANSLATIONS:
  1470.                 {
  1471.                     struct TranslationEntry    **Send,
  1472.                                 **Receive = NULL;
  1473.                     BYTE            Success = FALSE;
  1474.  
  1475.                     if(Send = AllocTranslationTable())
  1476.                     {
  1477.                         if(Receive = AllocTranslationTable())
  1478.                         {
  1479.                             if(!(Success = LoadTranslationTables(FileName,Send,Receive)))
  1480.                             {
  1481.                                 Results[0] = RC_ERROR;
  1482.                                 Results[1] = IoErr();
  1483.                             }
  1484.                         }
  1485.                         else
  1486.                         {
  1487.                             Results[0] = RC_ERROR;
  1488.                             Results[1] = ERROR_NO_FREE_STORE;
  1489.                         }
  1490.                     }
  1491.                     else
  1492.                     {
  1493.                         Results[0] = RC_ERROR;
  1494.                         Results[1] = ERROR_NO_FREE_STORE;
  1495.                     }
  1496.  
  1497.                     if(!Success)
  1498.                     {
  1499.                         if(Send)
  1500.                             FreeTranslationTable(Send);
  1501.  
  1502.                         if(Receive)
  1503.                             FreeTranslationTable(Receive);
  1504.                     }
  1505.                     else
  1506.                     {
  1507.                         strcpy(Config -> TranslationFileName,FileName);
  1508.  
  1509.                         strcpy(LastTranslation,FileName);
  1510.  
  1511.                         FreeTranslationTable(SendTable);
  1512.                         FreeTranslationTable(ReceiveTable);
  1513.  
  1514.                         SendTable    = Send;
  1515.                         ReceiveTable    = Receive;
  1516.                     }
  1517.                 }
  1518.  
  1519.                 break;
  1520.  
  1521.                 case DATATYPE_FUNCTIONKEYS:
  1522.                 {
  1523.                     if(!LoadMacros(FileName,MacroKeys))
  1524.                     {
  1525.                         Results[0] = RC_ERROR;
  1526.                         Results[1] = IoErr();
  1527.                     }
  1528.                     else
  1529.                     {
  1530.                         MacroChanged = FALSE;
  1531.  
  1532.                         strcpy(Config -> MacroFileName,FileName);
  1533.  
  1534.                         strcpy(LastMacros,FileName);
  1535.                     }
  1536.                 }
  1537.  
  1538.                 break;
  1539.  
  1540.                 case DATATYPE_CURSORKEYS:
  1541.                 {
  1542.                     if(!ReadIFFData(FileName,CursorKeys,sizeof(struct CursorKeys),ID_KEYS))
  1543.                     {
  1544.                         Results[0] = RC_ERROR;
  1545.                         Results[1] = IoErr();
  1546.                     }
  1547.                     else
  1548.                     {
  1549.                         CursorKeysChanged = FALSE;
  1550.  
  1551.                         strcpy(Config -> CursorFileName,FileName);
  1552.  
  1553.                         strcpy(LastCursorKeys,FileName);
  1554.                     }
  1555.                 }
  1556.  
  1557.                 break;
  1558.  
  1559.                 case DATATYPE_FASTMACROS:
  1560.                 {
  1561.                     if(!LoadFastMacros(FileName,&FastMacroList))
  1562.                     {
  1563.                         Results[0] = RC_ERROR;
  1564.                         Results[1] = IoErr();
  1565.                     }
  1566.                     else
  1567.                     {
  1568.                         strcpy(Config -> FastMacroFileName,FileName);
  1569.  
  1570.                         strcpy(LastFastMacros,FileName);
  1571.  
  1572.                         FastMacrosChanged = FALSE;
  1573.                     }
  1574.  
  1575.                     RefreshFastWindow(TRUE);
  1576.                 }
  1577.  
  1578.                 break;
  1579.  
  1580.                 case DATATYPE_HOTKEYS:
  1581.                 {
  1582.                     if(!LoadHotkeys(FileName,&Hotkeys))
  1583.                     {
  1584.                         Results[0] = RC_ERROR;
  1585.                         Results[1] = IoErr();
  1586.                     }
  1587.                     else
  1588.                     {
  1589.                         strcpy(LastKeys,FileName);
  1590.  
  1591.                         HotkeysChanged = FALSE;
  1592.  
  1593.                         SetupCx();
  1594.                     }
  1595.                 }
  1596.  
  1597.                 break;
  1598.  
  1599.                 case DATATYPE_SPEECH:
  1600.                 {
  1601.                     if(!ReadIFFData(FileName,&SpeechConfig,sizeof(struct SpeechConfig),ID_SPEK))
  1602.                     {
  1603.                         Results[0] = RC_ERROR;
  1604.                         Results[1] = IoErr();
  1605.                     }
  1606.                     else
  1607.                     {
  1608.                         strcpy(LastSpeech,FileName);
  1609.  
  1610.                         SpeechSetup();
  1611.  
  1612.                         SpeechChanged = FALSE;
  1613.                     }
  1614.                 }
  1615.  
  1616.                 break;
  1617.  
  1618.                 case DATATYPE_SOUND:
  1619.                 {
  1620.                     if(!ReadIFFData(FileName,&SoundConfig,sizeof(struct SoundConfig),ID_SOUN))
  1621.                     {
  1622.                         Results[0] = RC_ERROR;
  1623.                         Results[1] = IoErr();
  1624.                     }
  1625.                     else
  1626.                     {
  1627.                         strcpy(LastSound,FileName);
  1628.  
  1629.                         SoundInit();
  1630.  
  1631.                         SoundChanged = FALSE;
  1632.                     }
  1633.                 }
  1634.  
  1635.                 break;
  1636.  
  1637.                 case DATATYPE_BUFFER:
  1638.                 {
  1639.                     BPTR SomeFile;
  1640.  
  1641.                     if(SomeFile = Open(FileName,MODE_OLDFILE))
  1642.                     {
  1643.                         LONG Len;
  1644.  
  1645.                         LineRead(NULL,NULL,NULL);
  1646.  
  1647.                         while((Len = LineRead(SomeFile,FileName,80)) > 0)
  1648.                             CaptureParser(FileName,Len,AddLine);
  1649.  
  1650.                         Close(SomeFile);
  1651.  
  1652.                         BufferChanged = TRUE;
  1653.                     }
  1654.                     else
  1655.                     {
  1656.                         Results[0] = RC_ERROR;
  1657.                         Results[1] = IoErr();
  1658.                     }
  1659.                 }
  1660.  
  1661.                 break;
  1662.  
  1663.                 case DATATYPE_CONFIGURATION:
  1664.                 {
  1665.                     if(ReadConfig(FileName,PrivateConfig))
  1666.                     {
  1667.                         SwapConfig(PrivateConfig,Config);
  1668.  
  1669.                         strcpy(LastConfig,FileName);
  1670.  
  1671.                         ConfigSetup();
  1672.  
  1673.                         ConfigChanged = FALSE;
  1674.                     }
  1675.                     else
  1676.                     {
  1677.                         Results[0] = RC_ERROR;
  1678.                         Results[1] = IoErr();
  1679.                     }
  1680.                 }
  1681.  
  1682.                 break;
  1683.  
  1684.                 case DATATYPE_PHONEBOOK:
  1685.                 {
  1686.                     if(ChosenEntry)
  1687.                     {
  1688.                         Results[0] = RC_ERROR;
  1689.                         Results[1] = ERROR_OBJECT_IN_USE;
  1690.                     }
  1691.                     else
  1692.                     {
  1693.                         if(!LoadPhonebook(FileName,NULL))
  1694.                         {
  1695.                             Results[0] = RC_ERROR;
  1696.                             Results[1] = IoErr();
  1697.                         }
  1698.                         else
  1699.                         {
  1700.                             strcpy(LastPhone,FileName);
  1701.  
  1702.                             PhonebookChanged = FALSE;
  1703.  
  1704.                             RebuildMenu = TRUE;
  1705.                         }
  1706.                     }
  1707.                 }
  1708.  
  1709.                 break;
  1710.             }
  1711.  
  1712.             ReleaseWindows();
  1713.         }
  1714.         else
  1715.             Results[0] = RC_WARN;
  1716.     }
  1717.  
  1718.     return(NULL);
  1719. }
  1720.  
  1721. STRPTR
  1722. RexxOpenDevice(struct RexxPkt *Pkt)
  1723. {
  1724.     enum    {    ARG_OPENDEVICE_NAME,ARG_OPENDEVICE_UNIT };
  1725.  
  1726.     if(ReadRequest)
  1727.     {
  1728.         Results[0] = RC_ERROR;
  1729.         Results[1] = TERMERROR_DEVICE_DRIVER_STILL_OPEN;
  1730.     }
  1731.     else
  1732.     {
  1733.         if(Args[ARG_OPENDEVICE_NAME])
  1734.         {
  1735.             strcpy(Config -> SerialConfig -> SerialDevice,Args[ARG_OPENDEVICE_NAME]);
  1736.  
  1737.             ConfigChanged = TRUE;
  1738.         }
  1739.  
  1740.         if(Args[ARG_OPENDEVICE_UNIT])
  1741.         {
  1742.             Config -> SerialConfig -> UnitNumber = *(LONG *)Args[ARG_OPENDEVICE_UNIT];
  1743.  
  1744.             ConfigChanged = TRUE;
  1745.         }
  1746.  
  1747.         BlockWindows();
  1748.  
  1749.         ReopenSerial();
  1750.  
  1751.         ReleaseWindows();
  1752.     }
  1753.  
  1754.     return(NULL);
  1755. }
  1756.  
  1757. STRPTR
  1758. RexxOpenRequester(struct RexxPkt *Pkt)
  1759. {
  1760.     enum    {    ARG_OPENREQUESTER_REQUESTER };
  1761.  
  1762.     WORD Index;
  1763.  
  1764.     if((Index = ToRequester(Args[ARG_OPENREQUESTER_REQUESTER])) == -1)
  1765.     {
  1766.         Results[0] = RC_ERROR;
  1767.         Results[1] = ERROR_OBJECT_NOT_FOUND;
  1768.     }
  1769.     else
  1770.     {
  1771.         ULONG    Code;
  1772.         WORD    i;
  1773.  
  1774.         switch(Index)
  1775.         {
  1776.             case REQUESTER_SERIAL:
  1777.  
  1778.                 Code = MEN_SERIAL;
  1779.                 break;
  1780.  
  1781.             case REQUESTER_MODEM:
  1782.  
  1783.                 Code = MEN_MODEM;
  1784.                 break;
  1785.  
  1786.             case REQUESTER_SCREEN:
  1787.  
  1788.                 Code = MEN_SCREEN;
  1789.                 break;
  1790.  
  1791.             case REQUESTER_TERMINAL:
  1792.  
  1793.                 Code = MEN_TERMINAL;
  1794.                 break;
  1795.  
  1796.             case REQUESTER_EMULATION:
  1797.  
  1798.                 Code = MEN_SET_EMULATION;
  1799.                 break;
  1800.  
  1801.             case REQUESTER_CLIPBOARD:
  1802.  
  1803.                 Code = MEN_CLIPBOARD;
  1804.                 break;
  1805.  
  1806.             case REQUESTER_CAPTURE:
  1807.  
  1808.                 Code = MEN_CAPTURE;
  1809.                 break;
  1810.  
  1811.             case REQUESTER_COMMANDS:
  1812.  
  1813.                 Code = MEN_COMMANDS;
  1814.                 break;
  1815.  
  1816.             case REQUESTER_MISC:
  1817.  
  1818.                 Code = MEN_MISC;
  1819.                 break;
  1820.  
  1821.             case REQUESTER_PATH:
  1822.  
  1823.                 Code = MEN_PATH;
  1824.                 break;
  1825.  
  1826.             case REQUESTER_TRANSFER:
  1827.  
  1828.                 Code = MEN_TRANSFER;
  1829.                 break;
  1830.  
  1831.             case REQUESTER_TRANSLATIONS:
  1832.  
  1833.                 Code = MEN_TRANSLATION;
  1834.                 break;
  1835.  
  1836.             case REQUESTER_FUNCTIONKEYS:
  1837.  
  1838.                 Code = MEN_MACROS;
  1839.                 break;
  1840.  
  1841.             case REQUESTER_CURSORKEYS:
  1842.  
  1843.                 Code = MEN_CURSORKEYS;
  1844.                 break;
  1845.  
  1846.             case REQUESTER_FASTMACROS:
  1847.  
  1848.                 Code = MEN_FAST_MACROS;
  1849.                 break;
  1850.  
  1851.             case REQUESTER_HOTKEYS:
  1852.  
  1853.                 Code = MEN_HOTKEYS;
  1854.                 break;
  1855.  
  1856.             case REQUESTER_SPEECH:
  1857.  
  1858.                 Code = MEN_SPEECH;
  1859.                 break;
  1860.  
  1861.             case REQUESTER_SOUND:
  1862.  
  1863.                 Code = MEN_SOUND;
  1864.                 break;
  1865.  
  1866.  
  1867.             case REQUESTER_PHONE:
  1868.  
  1869.                 Code = MEN_PHONEBOOK;
  1870.                 break;
  1871.         }
  1872.  
  1873.             /* Scan the menu list... */
  1874.  
  1875.         for(i = 0 ; TermMenu[i] . nm_Type != NM_END ; i++)
  1876.         {
  1877.                 /* Did we get a valid name string? */
  1878.  
  1879.             if(TermMenu[i] . nm_Label != NM_BARLABEL)
  1880.             {
  1881.                 if((ULONG)TermMenu[i] . nm_UserData == Code)
  1882.                 {
  1883.                     HandleMenuCode((ULONG)TermMenu[i] . nm_UserData,NULL);
  1884.  
  1885.                     break;
  1886.                 }
  1887.             }
  1888.         }
  1889.     }
  1890.  
  1891.     return(NULL);
  1892. }
  1893.  
  1894. STRPTR
  1895. RexxParity(struct RexxPkt *Pkt)
  1896. {
  1897.     enum    {    ARG_PARITY_EVEN,ARG_PARITY_ODD,ARG_PARITY_NONE,ARG_PARITY_MARK,ARG_PARITY_SPACE };
  1898.  
  1899.     BYTE Mode;
  1900.  
  1901.     if(Args[ARG_PARITY_EVEN])
  1902.         Mode = PARITY_EVEN;
  1903.  
  1904.     if(Args[ARG_PARITY_ODD])
  1905.         Mode = PARITY_ODD;
  1906.  
  1907.     if(Args[ARG_PARITY_NONE])
  1908.         Mode = PARITY_NONE;
  1909.  
  1910.     if(Args[ARG_PARITY_MARK])
  1911.         Mode = PARITY_MARK;
  1912.  
  1913.     if(Args[ARG_PARITY_SPACE])
  1914.         Mode = PARITY_SPACE;
  1915.  
  1916.     if(Config -> SerialConfig -> Parity != Mode)
  1917.     {
  1918.         Config -> SerialConfig -> Parity = Mode;
  1919.  
  1920.         UpdateRequired = TRUE;
  1921.  
  1922.         ConfigChanged = TRUE;
  1923.     }
  1924.  
  1925.     return(NULL);
  1926. }
  1927.  
  1928. STRPTR
  1929. RexxPasteClip(struct RexxPkt *Pkt)
  1930. {
  1931.     enum    {    ARG_PASTECLIP_UNIT };
  1932.  
  1933.     struct DataMsg    *Msg;
  1934.     LONG         Unit;
  1935.  
  1936.     if(Args[ARG_PASTECLIP_UNIT])
  1937.         Unit = *(LONG *)Args[ARG_PASTECLIP_UNIT];
  1938.     else
  1939.         Unit = Config -> ClipConfig -> ClipboardUnit;
  1940.  
  1941.     if(Msg = (struct DataMsg *)CreateMsgItem(sizeof(struct DataMsg)))
  1942.     {
  1943.         Msg -> Type = DATAMSGTYPE_WRITECLIP;
  1944.         Msg -> Size = Unit;
  1945.  
  1946.         PutMsgItem(SpecialQueue,(struct MsgItem *)Msg);
  1947.     }
  1948.     else
  1949.     {
  1950.         Results[0] = RC_ERROR;
  1951.         Results[1] = ERROR_NO_FREE_STORE;
  1952.     }
  1953.  
  1954.     return(NULL);
  1955. }
  1956.  
  1957. STRPTR
  1958. RexxPrint(struct RexxPkt *Pkt)
  1959. {
  1960.     enum    {    ARG_PRINT_FROM,ARG_PRINT_TO,ARG_PRINT_SERIAL,ARG_PRINT_MODEM,ARG_PRINT_SCREEN,
  1961.             ARG_PRINT_TERMINAL,ARG_PRINT_USER,ARG_PRINT_COMMENT,ARG_PRINT_SIZE,
  1962.             ARG_PRINT_DATE,ARG_PRINT_BITS };
  1963.  
  1964.     WORD    Index,Mode = -1;
  1965.     ULONG    Flags = NULL;
  1966.  
  1967.     if(Args[ARG_PRINT_SERIAL])
  1968.         Flags |= PRINT_SERIAL;
  1969.  
  1970.     if(Args[ARG_PRINT_MODEM])
  1971.         Flags |= PRINT_MODEM;
  1972.  
  1973.     if(Args[ARG_PRINT_SCREEN])
  1974.         Flags |= PRINT_SCREEN;
  1975.  
  1976.     if(Args[ARG_PRINT_TERMINAL])
  1977.         Flags |= PRINT_TERMINAL;
  1978.  
  1979.     if(Args[ARG_PRINT_USER])
  1980.         Flags |= PRINT_USERNAME;
  1981.  
  1982.     if(Args[ARG_PRINT_COMMENT])
  1983.         Flags |= PRINT_COMMENT;
  1984.  
  1985.     if(Args[ARG_PRINT_SIZE])
  1986.         Flags |= PRINT_SIZE;
  1987.  
  1988.     if(Args[ARG_PRINT_DATE])
  1989.         Flags |= PRINT_DATE;
  1990.  
  1991.     if(Args[ARG_PRINT_BITS])
  1992.         Flags |= PRINT_BITS;
  1993.  
  1994.     if((Index = ToList(Args[ARG_PRINT_FROM])) == -1)
  1995.     {
  1996.         if(!Stricmp(Args[ARG_PRINT_FROM],"SCREENTEXT"))
  1997.         {
  1998.             if(!RasterEnabled)
  1999.             {
  2000.                 Results[0] = RC_ERROR;
  2001.                 Results[1] = TERMERROR_NO_DATA_TO_PROCESS;
  2002.  
  2003.                 return(NULL);
  2004.             }
  2005.             else
  2006.                 Mode = 0;
  2007.         }
  2008.  
  2009.         if(!Stricmp(Args[ARG_PRINT_FROM],"CLIPBOARD"))
  2010.             Mode = 1;
  2011.  
  2012.         if(!Stricmp(Args[ARG_PRINT_FROM],"BUFFER"))
  2013.             Mode = 2;
  2014.     }
  2015.  
  2016.     if(Index == -1 && Mode == -1)
  2017.     {
  2018.         Results[0] = RC_ERROR;
  2019.         Results[1] = TERMERROR_UNKNOWN_LIST;
  2020.     }
  2021.     else
  2022.     {
  2023.         BYTE    Continue = TRUE;
  2024.         LONG    Error = 0;
  2025.         BPTR    File;
  2026.         STRPTR    Name;
  2027.  
  2028.         if(Args[ARG_PRINT_TO])
  2029.             Name = Args[ARG_PRINT_TO];
  2030.         else
  2031.             Name = "PRT:";
  2032.  
  2033.         if(File = Open(Name,MODE_NEWFILE))
  2034.         {
  2035.             struct Window        *ReqWindow;
  2036.             struct EasyStruct     Easy;
  2037.  
  2038.             Easy . es_StructSize    = sizeof(struct EasyStruct);
  2039.             Easy . es_Flags        = NULL;
  2040.             Easy . es_Title        = (UBYTE *)LocaleString(MSG_TERMAUX_TERM_REQUEST_TXT);
  2041.             Easy . es_GadgetFormat    = (UBYTE *)LocaleString(MSG_PRINT_STOP_TXT);
  2042.             Easy . es_TextFormat    = (UBYTE *)LocaleString(MSG_GLOBAL_PRINTING_TXT);
  2043.  
  2044.             BlockWindows();
  2045.  
  2046.             if(ReqWindow = BuildEasyRequest(Window,&Easy,NULL))
  2047.             {
  2048.                 switch(Index)
  2049.                 {
  2050.                     case GLIST_DIAL:
  2051.                     {
  2052.                         struct GenericList *List = GenericListTable[Index];
  2053.  
  2054.                         ObtainSemaphore(&List -> ListSemaphore);
  2055.  
  2056.                         if(List -> ListHeader . mlh_Head -> mln_Succ)
  2057.                         {
  2058.                             struct DialNode *TempNode;
  2059.  
  2060.                             for(TempNode = (struct DialNode *)List -> ListHeader . mlh_Head ; Continue && TempNode -> Node . ln_Succ ; TempNode = (struct DialNode *)TempNode -> Node . ln_Succ)
  2061.                             {
  2062.                                 if(TempNode -> Entry)
  2063.                                     Continue = PrintEntry(File,ReqWindow,TRUE,&Error,TempNode -> Entry,Flags);
  2064.                                 else
  2065.                                     Continue = PrintText(File,ReqWindow,&Error,"\n\"???\" (%s)",TempNode -> Node . ln_Name);
  2066.                             }
  2067.                         }
  2068.  
  2069.                         ReleaseSemaphore(&List -> ListSemaphore);
  2070.                     }
  2071.  
  2072.                     break;
  2073.  
  2074.                     case GLIST_UPLOAD:
  2075.                     case GLIST_DOWNLOAD:
  2076.                     {
  2077.                         struct GenericList *List = GenericListTable[Index];
  2078.  
  2079.                         ObtainSemaphore(&List -> ListSemaphore);
  2080.  
  2081.                         if(List -> ListHeader . mlh_Head -> mln_Succ)
  2082.                         {
  2083.                             struct Node *TempNode;
  2084.  
  2085.                             for(TempNode = (struct Node *)List -> ListHeader . mlh_Head ; Continue && TempNode -> ln_Succ ; TempNode = TempNode -> ln_Succ)
  2086.                                 Continue = PrintFileInformation(File,ReqWindow,&Error,TempNode -> ln_Name,Flags);
  2087.                         }
  2088.  
  2089.                         ReleaseSemaphore(&List -> ListSemaphore);
  2090.                     }
  2091.  
  2092.                     break;
  2093.  
  2094.                     case GLIST_WAIT:
  2095.                     {
  2096.                         struct GenericList *List = GenericListTable[Index];
  2097.  
  2098.                         ObtainSemaphore(&List -> ListSemaphore);
  2099.  
  2100.                         if(List -> ListHeader . mlh_Head -> mln_Succ)
  2101.                         {
  2102.                             struct Node *TempNode;
  2103.  
  2104.                             for(TempNode = (struct Node *)List -> ListHeader . mlh_Head ; Continue && TempNode -> ln_Succ ; TempNode = TempNode -> ln_Succ)
  2105.                                 Continue = PrintText(File,ReqWindow,&Error,"%s\n",TempNode -> ln_Name);
  2106.                         }
  2107.  
  2108.                         ReleaseSemaphore(&List -> ListSemaphore);
  2109.                     }
  2110.  
  2111.                     break;
  2112.  
  2113.                     default:
  2114.                     {
  2115.                         switch(Mode)
  2116.                         {
  2117.                             case 0:
  2118.  
  2119.                                 Continue = PrintScreen(File,ReqWindow,&Error);
  2120.                                 break;
  2121.  
  2122.                             case 1:
  2123.  
  2124.                                 Continue = PrintClip(File,ReqWindow,&Error);
  2125.                                 break;
  2126.  
  2127.                             case 2:
  2128.  
  2129.                                 Continue = PrintBuffer(File,ReqWindow,&Error);
  2130.                                 break;
  2131.                         }
  2132.  
  2133.                         break;
  2134.                     }
  2135.  
  2136.                     break;
  2137.                 }
  2138.  
  2139.                 FreeSysRequest(ReqWindow);
  2140.             }
  2141.  
  2142.             ReleaseWindows();
  2143.  
  2144.             Close(File);
  2145.         }
  2146.         else
  2147.             Error = IoErr();
  2148.  
  2149.         if(Error)
  2150.         {
  2151.             Results[0] = RC_ERROR;
  2152.             Results[1] = Error;
  2153.         }
  2154.         else
  2155.         {
  2156.             if(!Continue)
  2157.                 Results[0] = RC_WARN;
  2158.         }
  2159.     }
  2160.  
  2161.     return(NULL);
  2162. }
  2163.  
  2164. STRPTR
  2165. RexxProcessIO(struct RexxPkt *Pkt)
  2166. {
  2167.     enum    {    ARG_PROCESSIO_ON,ARG_PROCESSIO_OFF };
  2168.  
  2169.     Forbid();
  2170.  
  2171.     if(Args[ARG_PROCESSIO_ON])
  2172.         ProcessIO = TRUE;
  2173.  
  2174.     if(Args[ARG_PROCESSIO_OFF])
  2175.         ProcessIO = FALSE;
  2176.  
  2177.     Permit();
  2178.  
  2179.     return(NULL);
  2180. }
  2181.  
  2182. STRPTR
  2183. RexxProtocol(struct RexxPkt *Pkt)
  2184. {
  2185.     enum    {    ARG_PROTOCOL_NONE,ARG_PROTOCOL_RTSCTS,ARG_PROTOCOL_RTSCTSDTR };
  2186.  
  2187.     BYTE Mode;
  2188.  
  2189.     if(Args[ARG_PROTOCOL_NONE])
  2190.         Mode = HANDSHAKING_NONE;
  2191.  
  2192.     if(Args[ARG_PROTOCOL_RTSCTS])
  2193.         Mode = HANDSHAKING_RTSCTS;
  2194.  
  2195.     if(Args[ARG_PROTOCOL_RTSCTSDTR])
  2196.         Mode = HANDSHAKING_RTSCTS_DSR;
  2197.  
  2198.     if(Config -> SerialConfig -> HandshakingProtocol != Mode)
  2199.     {
  2200.         Config -> SerialConfig -> HandshakingProtocol = Mode;
  2201.  
  2202.         UpdateRequired = TRUE;
  2203.  
  2204.         ConfigChanged = TRUE;
  2205.     }
  2206.  
  2207.     return(NULL);
  2208. }
  2209.  
  2210. STRPTR
  2211. RexxPutClip(struct RexxPkt *Pkt)
  2212. {
  2213.     enum    {    ARG_PUTCLIP_UNIT,ARG_PUTCLIP_TEXT };
  2214.  
  2215.     struct IFFHandle    *Handle;
  2216.     LONG             Unit;
  2217.     BYTE             Success = FALSE;
  2218.  
  2219.     if(Args[ARG_PUTCLIP_UNIT])
  2220.         Unit = *(LONG *)Args[ARG_PUTCLIP_UNIT];
  2221.     else
  2222.         Unit = Config -> ClipConfig -> ClipboardUnit;
  2223.  
  2224.     if(Handle = AllocIFF())
  2225.     {
  2226.         if(Handle -> iff_Stream = (ULONG)OpenClipboard(Unit))
  2227.         {
  2228.             InitIFFasClip(Handle);
  2229.  
  2230.             if(!OpenIFF(Handle,IFFF_WRITE))
  2231.             {
  2232.                 if(!PushChunk(Handle,ID_FTXT,ID_FORM,IFFSIZE_UNKNOWN))
  2233.                 {
  2234.                     if(!PushChunk(Handle,0,ID_CHRS,IFFSIZE_UNKNOWN))
  2235.                     {
  2236.                         LONG Len = strlen(Args[ARG_PUTCLIP_TEXT]);
  2237.  
  2238.                         if(WriteChunkBytes(Handle,Args[ARG_PUTCLIP_TEXT],Len) == Len)
  2239.                         {
  2240.                             if(!PopChunk(Handle))
  2241.                                 Success = TRUE;
  2242.                         }
  2243.                     }
  2244.                 }
  2245.  
  2246.                 if(PopChunk(Handle))
  2247.                     Success = FALSE;
  2248.  
  2249.                 CloseIFF(Handle);
  2250.             }
  2251.             else
  2252.             {
  2253.                 Results[0] = RC_ERROR;
  2254.                 Results[1] = ERROR_NO_FREE_STORE;
  2255.             }
  2256.  
  2257.             CloseClipboard((struct ClipboardHandle *)Handle -> iff_Stream);
  2258.         }
  2259.         else
  2260.         {
  2261.             Results[0] = RC_ERROR;
  2262.             Results[1] = TERMERROR_UNIT_NOT_AVAILABLE;
  2263.         }
  2264.  
  2265.         FreeIFF(Handle);
  2266.     }
  2267.     else
  2268.     {
  2269.         Results[0] = RC_ERROR;
  2270.         Results[1] = ERROR_NO_FREE_STORE;
  2271.     }
  2272.  
  2273.     if(!Success && !Results[0])
  2274.     {
  2275.         Results[0] = RC_ERROR;
  2276.         Results[1] = TERMERROR_CLIPBOARD_ERROR;
  2277.     }
  2278.  
  2279.     return(NULL);
  2280. }
  2281.  
  2282. STRPTR
  2283. RexxQuit(struct RexxPkt *Pkt)
  2284. {
  2285.     enum    {    ARG_QUIT_FORCE };
  2286.  
  2287.     struct DataMsg *Msg;
  2288.  
  2289.     if(Msg = (struct DataMsg *)CreateMsgItem(sizeof(struct DataMsg)))
  2290.     {
  2291.         Pkt -> RexxMsg -> rm_Result1 = RC_WARN;
  2292.         Pkt -> RexxMsg -> rm_Result2 = 0;
  2293.  
  2294.         ReplyMsg(Pkt -> RexxMsg);
  2295.  
  2296.         Pkt -> RexxMsg = NULL;
  2297.  
  2298.         Msg -> Type = DATAMSGTYPE_MENU;
  2299.         Msg -> Size = MEN_QUIT;
  2300.  
  2301.         if(Args[ARG_QUIT_FORCE])
  2302.             Msg -> Data = (APTR)(IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT);
  2303.         else
  2304.             Msg -> Data = NULL;
  2305.  
  2306.         PutMsgItem(SpecialQueue,(struct MsgItem *)Msg);
  2307.     }
  2308.     else
  2309.     {
  2310.         Results[0] = RC_ERROR;
  2311.         Results[1] = ERROR_NO_FREE_STORE;
  2312.     }
  2313.  
  2314.     return(NULL);
  2315. }
  2316.  
  2317. STATIC STRPTR    RexxReadBuffer;
  2318. STATIC LONG    RexxReadIndex,
  2319.         RexxReadLen;
  2320. STATIC BYTE    RexxReadDone,
  2321.         RexxReadEcho;
  2322.  
  2323. STATIC BOOLEAN
  2324. RexxReadBypassVerbatim(STRPTR Buffer,LONG Size)
  2325. {
  2326.     while(Size-- > 0)
  2327.     {
  2328.         switch(*Buffer)
  2329.         {
  2330.             case '\n':
  2331.  
  2332.                 break;
  2333.  
  2334.             case '\r':
  2335.  
  2336.                 RexxReadDone = TRUE;
  2337.                 break;
  2338.  
  2339.             case '\b':
  2340.             case '\30':
  2341.  
  2342.                 while(RexxReadIndex > 0)
  2343.                 {
  2344.                     if(RexxReadEcho)
  2345.                         SerWriteVerbatim("\b",1,FALSE);
  2346.  
  2347.                     RexxReadIndex--;
  2348.                 }
  2349.  
  2350.                 break;
  2351.  
  2352.             default:
  2353.  
  2354.                 if(RexxReadIndex < RexxReadLen && ((*Buffer >= ' ' && *Buffer < 127) || *Buffer >= 160 || Config -> TerminalConfig -> FontMode == FONT_IBM))
  2355.                 {
  2356.                     RexxReadBuffer[RexxReadIndex++] = *Buffer;
  2357.  
  2358.                     if(RexxReadEcho)
  2359.                         SerWriteVerbatim(Buffer,1,FALSE);
  2360.                 }
  2361.  
  2362.                 break;
  2363.         }
  2364.  
  2365.         Buffer++;
  2366.     }
  2367.  
  2368.     return(FALSE);
  2369. }
  2370.  
  2371. STATIC BOOLEAN
  2372. RexxReadBypassTranslate(STRPTR Buffer,LONG Size)
  2373. {
  2374.     struct TranslationHandle    Handle;
  2375.     UBYTE                Temp;
  2376.  
  2377.     while(Size-- > 0)
  2378.     {
  2379.         TranslateSetup(&Handle,Buffer,1,&Temp,1,ReceiveTable);
  2380.  
  2381.         while(!RexxReadDone && TranslateBuffer(&Handle))
  2382.         {
  2383.             switch(Temp)
  2384.             {
  2385.                 case '\n':
  2386.  
  2387.                     break;
  2388.  
  2389.                 case '\r':
  2390.  
  2391.                     RexxReadDone = TRUE;
  2392.  
  2393.                     break;
  2394.  
  2395.                 case '\b':
  2396.                 case '\30':
  2397.  
  2398.                     while(RexxReadIndex > 0)
  2399.                     {
  2400.                         if(RexxReadEcho)
  2401.                             SerWriteVerbatim("\b",1,FALSE);
  2402.  
  2403.                         RexxReadIndex--;
  2404.                     }
  2405.  
  2406.                     break;
  2407.  
  2408.                 default:
  2409.  
  2410.                     if(RexxReadIndex < RexxReadLen && ((Temp >= ' ' && Temp < 127) || Temp >= 160 || Config -> TerminalConfig -> FontMode == FONT_IBM))
  2411.                     {
  2412.                         RexxReadBuffer[RexxReadIndex++] = Temp;
  2413.  
  2414.                         if(RexxReadEcho)
  2415.                             SerWriteVerbatim(&Temp,1,FALSE);
  2416.                     }
  2417.  
  2418.                     break;
  2419.             }
  2420.         }
  2421.  
  2422.         Buffer++;
  2423.     }
  2424.  
  2425.     return(FALSE);
  2426. }
  2427.  
  2428. STRPTR
  2429. RexxRead(struct RexxPkt *Pkt)
  2430. {
  2431.     enum    {    ARG_READ_NUM,ARG_READ_CR,ARG_READ_NOECHO,ARG_READ_VERBATIM,ARG_READ_PROMPT };
  2432.  
  2433.     LONG Len,BytesRead = 0;
  2434.  
  2435.     if(!ReadRequest || !WriteRequest)
  2436.     {
  2437.         Results[0] = RC_WARN;
  2438.  
  2439.         return(NULL);
  2440.     }
  2441.  
  2442.     if(Args[ARG_READ_NUM])
  2443.     {
  2444.         Len = *(LONG *)Args[ARG_READ_NUM] + 1;
  2445.  
  2446.         if(Len < 1)
  2447.         {
  2448.             Results[0] = RC_ERROR;
  2449.             Results[1] = ERROR_BAD_NUMBER;
  2450.  
  2451.             return(NULL);
  2452.         }
  2453.  
  2454.         if(Len > MAX_RESULT_LEN + 1)
  2455.             Len = MAX_RESULT_LEN + 1;
  2456.     }
  2457.     else
  2458.         Len = MAX_RESULT_LEN + 1;
  2459.  
  2460.     if(Args[ARG_READ_PROMPT])
  2461.         SerialCommand(Args[ARG_READ_PROMPT]);
  2462.  
  2463.     if(Marking)
  2464.         DropMarker();
  2465.  
  2466.     BlockWindows();
  2467.  
  2468.     if(Args[ARG_READ_CR])
  2469.     {
  2470.         Forbid();
  2471.  
  2472.         LT_UnlockWindow(Window);
  2473.  
  2474.         Window -> Flags |= WFLG_RMBTRAP;
  2475.  
  2476.         Permit();
  2477.  
  2478.         NormalCursor();
  2479.     }
  2480.  
  2481.     Status = STATUS_READY;
  2482.  
  2483.     if(Args[ARG_READ_VERBATIM] || !ReceiveTable)
  2484.     {
  2485.         if(Args[ARG_READ_CR])
  2486.         {
  2487.             ULONG     Signals,SignalMask = SIG_SERIAL | SIG_TIMER | SIG_BREAK;
  2488.             UBYTE    *Char;
  2489.             BYTE     Echo,Done = FALSE;
  2490.             LONG     Index = 0;
  2491.             STRPTR     Buffer;
  2492.  
  2493.             if(Buffer = (STRPTR)AllocVecPooled(Len,MEMF_ANY))
  2494.             {
  2495.                 if(Args[ARG_READ_NOECHO])
  2496.                     Echo = FALSE;
  2497.                 else
  2498.                     Echo = TRUE;
  2499.  
  2500.                 RexxReadEcho = Echo;
  2501.  
  2502.                 if(RexxTimeoutVal)
  2503.                     StartTime(RexxTimeoutVal,0);
  2504.  
  2505.                 if(DataHold)
  2506.                 {
  2507.                     while(DataSize-- > 0)
  2508.                     {
  2509.                         Char = DataHold++;
  2510.  
  2511.                         switch(*Char)
  2512.                         {
  2513.                             case '\n':
  2514.  
  2515.                                 break;
  2516.  
  2517.                             case '\r':
  2518.  
  2519.                                 Done = TRUE;
  2520.  
  2521.                                 if(Echo)
  2522.                                     SerWrite(ReadBuffer,1);
  2523.  
  2524.                                 break;
  2525.  
  2526.                             case '\b':
  2527.  
  2528.                                 if(Index > 0)
  2529.                                 {
  2530.                                     Index--;
  2531.  
  2532.                                     if(Echo)
  2533.                                         SerWrite(ReadBuffer,1);
  2534.                                 }
  2535.  
  2536.                                 break;
  2537.  
  2538.                             case '\30':
  2539.  
  2540.                                 if(Echo)
  2541.                                 {
  2542.                                     while(Index > 0)
  2543.                                     {
  2544.                                         Index--;
  2545.  
  2546.                                         SerWrite("\b",1);
  2547.                                     }
  2548.                                 }
  2549.                                 else
  2550.                                     Index = 0;
  2551.  
  2552.                                 break;
  2553.  
  2554.                             default:
  2555.  
  2556.                                 if(Index < Len && ((*Char >= ' ' && *Char < 127) || *Char >= 160 || Config -> TerminalConfig -> FontMode == FONT_IBM))
  2557.                                 {
  2558.                                     Buffer[Index++] = *Char;
  2559.  
  2560.                                     if(Echo)
  2561.                                         SerWrite(ReadBuffer,1);
  2562.                                 }
  2563.  
  2564.                                 break;
  2565.                         }
  2566.                     }
  2567.  
  2568.                     DataHold = NULL;
  2569.  
  2570.                     RestartSerial();
  2571.                 }
  2572.  
  2573.                 if(CheckSerialRead())
  2574.                     Signals = SIG_SERIAL;
  2575.                 else
  2576.                     Signals = NULL;
  2577.  
  2578.                 do
  2579.                 {
  2580.                     if(Signals & SIG_WINDOW)
  2581.                     {
  2582.                         SerWriteBypass = RexxReadBypassVerbatim;
  2583.  
  2584.                         RexxReadBuffer    = Buffer;
  2585.                         RexxReadIndex    = Index;
  2586.                         RexxReadLen    = Len;
  2587.                         RexxReadDone    = Done;
  2588.  
  2589.                         while(HandleWindow());
  2590.  
  2591.                         Buffer    = RexxReadBuffer;
  2592.                         Index    = RexxReadIndex;
  2593.                         Len    = RexxReadLen;
  2594.                         Done    = RexxReadDone;
  2595.  
  2596.                         SerWriteBypass = NULL;
  2597.                     }
  2598.  
  2599.                     if(Signals & SIG_SERIAL)
  2600.                     {
  2601.                         if(!WaitSerialRead())
  2602.                         {
  2603.                             LONG Length;
  2604.  
  2605.                             BytesIn++;
  2606.  
  2607.                             if(Translate_CR_LF)
  2608.                                 Length = (* Translate_CR_LF)(ReadBuffer,1);
  2609.                             else
  2610.                                 Length = 1;
  2611.  
  2612.                             Char = ReadBuffer;
  2613.  
  2614.                             while(Length--)
  2615.                             {
  2616.                                 switch(*Char)
  2617.                                 {
  2618.                                     case '\n':
  2619.  
  2620.                                         break;
  2621.  
  2622.                                     case '\r':
  2623.  
  2624.                                         Done = TRUE;
  2625.  
  2626.                                         if(Echo)
  2627.                                             SerWrite(ReadBuffer,1);
  2628.  
  2629.                                         break;
  2630.  
  2631.                                     case '\b':
  2632.  
  2633.                                         if(Index > 0)
  2634.                                         {
  2635.                                             Index--;
  2636.  
  2637.                                             if(Echo)
  2638.                                                 SerWrite(ReadBuffer,1);
  2639.                                         }
  2640.  
  2641.                                         break;
  2642.  
  2643.                                     case '\30':
  2644.  
  2645.                                         if(Echo)
  2646.                                         {
  2647.                                             while(Index > 0)
  2648.                                             {
  2649.                                                 Index--;
  2650.  
  2651.                                                 SerWrite("\b",1);
  2652.                                             }
  2653.                                         }
  2654.                                         else
  2655.                                             Index = 0;
  2656.  
  2657.                                     default:
  2658.  
  2659.                                         if(Index < Len && ((*Char >= ' ' && *Char < 127) || *Char >= 160 || Config -> TerminalConfig -> FontMode == FONT_IBM))
  2660.                                         {
  2661.                                             Buffer[Index++] = *Char;
  2662.  
  2663.                                             if(Echo)
  2664.                                                 SerWrite(ReadBuffer,1);
  2665.                                         }
  2666.  
  2667.                                         break;
  2668.                                 }
  2669.  
  2670.                                 Char++;
  2671.                             }
  2672.                         }
  2673.  
  2674.                         RestartSerial();
  2675.                     }
  2676.  
  2677.                     if(Signals & (SIG_BREAK | SIG_TIMER))
  2678.                     {
  2679.                         Results[0] = RC_WARN;
  2680.  
  2681.                         break;
  2682.                     }
  2683.  
  2684.                     if(!Done)
  2685.                         Signals = Wait(SignalMask | SIG_WINDOW);
  2686.                 }
  2687.                 while(!Done);
  2688.  
  2689.                 if(RexxTimeoutVal)
  2690.                     StopTime();
  2691.  
  2692.                 if(Index)
  2693.                 {
  2694.                     STRPTR Result;
  2695.  
  2696.                     Buffer[Index] = 0;
  2697.  
  2698.                     Result = CreateResult(Buffer,Results);
  2699.  
  2700.                     if(Args[ARG_READ_CR])
  2701.                     {
  2702.                         Forbid();
  2703.  
  2704.                         Window -> Flags &= ~WFLG_RMBTRAP;
  2705.  
  2706.                         LT_LockWindow(Window);
  2707.  
  2708.                         Permit();
  2709.                     }
  2710.  
  2711.                     ReleaseWindows();
  2712.  
  2713.                     FreeVecPooled(Buffer);
  2714.  
  2715.                     return(Result);
  2716.                 }
  2717.                 else
  2718.                     Results[0] = RC_WARN;
  2719.  
  2720.                 FreeVecPooled(Buffer);
  2721.             }
  2722.             else
  2723.             {
  2724.                 Results[0] = RC_ERROR;
  2725.                 Results[1] = ERROR_NO_FREE_STORE;
  2726.             }
  2727.         }
  2728.         else
  2729.         {
  2730.             STRPTR Buffer;
  2731.  
  2732.             if(Buffer = (STRPTR)AllocVecPooled(Len,MEMF_ANY))
  2733.             {
  2734.                 STRPTR Result;
  2735.  
  2736.                 if(DataHold && DataSize >= Len - 1)
  2737.                 {
  2738.                     CopyMem(DataHold,Buffer,Len - 1);
  2739.  
  2740.                     BytesRead = Len - 1;
  2741.  
  2742.                     if(DataSize == Len - 1)
  2743.                     {
  2744.                         DataHold = NULL;
  2745.  
  2746.                         RestartSerial();
  2747.                     }
  2748.                     else
  2749.                     {
  2750.                         DataHold += Len - 1;
  2751.                         DataSize -= Len - 1;
  2752.                     }
  2753.                 }
  2754.                 else
  2755.                 {
  2756.                     ULONG Signals,SignalMask = SIG_SERIAL | SIG_TIMER | SIG_BREAK;
  2757.  
  2758.                     ClearSerial();
  2759.  
  2760.                     ClrSignal(SignalMask);
  2761.  
  2762.                     if(RexxTimeoutVal)
  2763.                         StartTime(RexxTimeoutVal,0);
  2764.  
  2765.                     if(DataHold)
  2766.                     {
  2767.                         CopyMem(DataHold,Buffer,DataSize);
  2768.  
  2769.                         StartSerialRead(Buffer + DataSize,Len - 1 - DataSize);
  2770.  
  2771.                         BytesRead = DataSize;
  2772.  
  2773.                         DataHold = NULL;
  2774.                     }
  2775.                     else
  2776.                         StartSerialRead(Buffer,Len - 1);
  2777.  
  2778.                     FOREVER
  2779.                     {
  2780.                         Signals = Wait(SignalMask);
  2781.  
  2782.                         if(Signals & SIG_SERIAL)
  2783.                         {
  2784.                             if(RexxTimeoutVal)
  2785.                                 StopTime();
  2786.  
  2787.                                 /* Did the request terminate gracefully? */
  2788.  
  2789.                             if(!WaitSerialRead())
  2790.                             {
  2791.                                 BytesIn += ReadRequest -> IOSer . io_Actual;
  2792.  
  2793.                                 BytesRead = ReadRequest -> IOSer . io_Actual;
  2794.                             }
  2795.                             else
  2796.                                 Results[0] = RC_ERROR;
  2797.  
  2798.                             break;
  2799.                         }
  2800.  
  2801.                         if(Signals & SIG_BREAK)
  2802.                         {
  2803.                             StopSerialRead();
  2804.  
  2805.                             if(RexxTimeoutVal)
  2806.                                 StopTime();
  2807.  
  2808.                             Results[0] = RC_WARN;
  2809.  
  2810.                             break;
  2811.                         }
  2812.  
  2813.                         if(Signals & SIG_TIMER)
  2814.                         {
  2815.                             StopSerialRead();
  2816.  
  2817.                             WaitIO(TimeRequest);
  2818.  
  2819.                             if(ReadRequest -> IOSer . io_Actual)
  2820.                             {
  2821.                                 BytesIn += ReadRequest -> IOSer . io_Actual;
  2822.  
  2823.                                 BytesRead = ReadRequest -> IOSer . io_Actual;
  2824.                             }
  2825.                             else
  2826.                             {
  2827.                                 ULONG Waiting = GetSerialWaiting();
  2828.  
  2829.                                 if(Waiting)
  2830.                                 {
  2831.                                         /* Don't read more than actually wanted. */
  2832.  
  2833.                                     if(!DoSerialRead(Buffer,MIN(Len - 1,Waiting)))
  2834.                                     {
  2835.                                         BytesIn += ReadRequest -> IOSer . io_Actual;
  2836.  
  2837.                                         BytesRead = ReadRequest -> IOSer . io_Actual;
  2838.                                     }
  2839.                                 }
  2840.                             }
  2841.  
  2842.                             break;
  2843.                         }
  2844.                     }
  2845.                 }
  2846.  
  2847.                 if(BytesRead)
  2848.                     Result = CreateResultLen(Buffer,Results,BytesRead);
  2849.                 else
  2850.                 {
  2851.                     Results[0] = RC_WARN;
  2852.  
  2853.                     Result = NULL;
  2854.                 }
  2855.  
  2856.                 FreeVecPooled(Buffer);
  2857.  
  2858.                 RestartSerial();
  2859.  
  2860.                 if(Args[ARG_READ_CR])
  2861.                 {
  2862.                     Forbid();
  2863.  
  2864.                     Window -> Flags &= ~WFLG_RMBTRAP;
  2865.  
  2866.                     LT_LockWindow(Window);
  2867.  
  2868.                     Permit();
  2869.                 }
  2870.  
  2871.                 ReleaseWindows();
  2872.  
  2873.                 return(Result);
  2874.             }
  2875.             else
  2876.             {
  2877.                 Results[0] = RC_ERROR;
  2878.                 Results[1] = ERROR_NO_FREE_STORE;
  2879.             }
  2880.  
  2881.             RestartSerial();
  2882.         }
  2883.     }
  2884.     else
  2885.     {
  2886.         if(Args[ARG_READ_CR])
  2887.         {
  2888.             ULONG                 Signals,SignalMask = SIG_SERIAL | SIG_TIMER | SIG_BREAK;
  2889.             UBYTE                *Char,Temp;
  2890.             BYTE                 Echo,Done = FALSE;
  2891.             LONG                 Index = 0;
  2892.             struct TranslationHandle     Handle;
  2893.             STRPTR                 Buffer;
  2894.  
  2895.             if(Buffer = (STRPTR)AllocVecPooled(Len,MEMF_ANY))
  2896.             {
  2897.                 if(Args[ARG_READ_NOECHO])
  2898.                     Echo = FALSE;
  2899.                 else
  2900.                     Echo = TRUE;
  2901.  
  2902.                 RexxReadEcho = Echo;
  2903.  
  2904.                 if(RexxTimeoutVal)
  2905.                     StartTime(RexxTimeoutVal,0);
  2906.  
  2907.                 if(DataHold)
  2908.                 {
  2909.                     while(DataSize-- > 0)
  2910.                     {
  2911.                         Char = DataHold++;
  2912.  
  2913.                         TranslateSetup(&Handle,Char,1,&Temp,1,ReceiveTable);
  2914.  
  2915.                         while(!Done && TranslateBuffer(&Handle))
  2916.                         {
  2917.                             switch(Temp)
  2918.                             {
  2919.                                 case '\n':
  2920.  
  2921.                                     break;
  2922.  
  2923.                                 case '\r':
  2924.  
  2925.                                     Done = TRUE;
  2926.  
  2927.                                     if(Echo)
  2928.                                         SerWrite(&Temp,1);
  2929.  
  2930.                                     break;
  2931.  
  2932.                                 case '\b':
  2933.  
  2934.                                     if(Index > 0)
  2935.                                     {
  2936.                                         Index--;
  2937.  
  2938.                                         if(Echo)
  2939.                                             SerWrite(&Temp,1);
  2940.                                     }
  2941.  
  2942.                                     break;
  2943.  
  2944.                                 case '\30':
  2945.  
  2946.                                     if(Echo)
  2947.                                     {
  2948.                                         while(Index > 0)
  2949.                                         {
  2950.                                             Index--;
  2951.  
  2952.                                             SerWrite("\b",1);
  2953.                                         }
  2954.                                     }
  2955.                                     else
  2956.                                         Index = 0;
  2957.  
  2958.                                     break;
  2959.  
  2960.                                 default:
  2961.  
  2962.                                     if(Index < Len && ((Temp >= ' ' && Temp < 127) || Temp >= 160 || Config -> TerminalConfig -> FontMode == FONT_IBM))
  2963.                                     {
  2964.                                         Buffer[Index++] = Temp;
  2965.  
  2966.                                         if(Echo)
  2967.                                             SerWrite(&Temp,1);
  2968.                                     }
  2969.  
  2970.                                     break;
  2971.                             }
  2972.                         }
  2973.                     }
  2974.  
  2975.                     DataHold = NULL;
  2976.  
  2977.                     RestartSerial();
  2978.                 }
  2979.  
  2980.                 if(CheckSerialRead())
  2981.                     Signals = SIG_SERIAL;
  2982.                 else
  2983.                     Signals = NULL;
  2984.  
  2985.                 do
  2986.                 {
  2987.                     if(Signals & SIG_WINDOW)
  2988.                     {
  2989.                         SerWriteBypass = RexxReadBypassTranslate;
  2990.  
  2991.                         RexxReadBuffer    = Buffer;
  2992.                         RexxReadIndex    = Index;
  2993.                         RexxReadLen    = Len;
  2994.                         RexxReadDone    = Done;
  2995.  
  2996.                         while(HandleWindow());
  2997.  
  2998.                         Buffer    = RexxReadBuffer;
  2999.                         Index    = RexxReadIndex;
  3000.                         Len    = RexxReadLen;
  3001.                         Done    = RexxReadDone;
  3002.  
  3003.                         SerWriteBypass = NULL;
  3004.                     }
  3005.  
  3006.                     if(Signals & SIG_SERIAL)
  3007.                     {
  3008.                         if(!WaitSerialRead())
  3009.                         {
  3010.                             LONG Length;
  3011.  
  3012.                             BytesIn++;
  3013.  
  3014.                             if(Translate_CR_LF)
  3015.                                 Length = (* Translate_CR_LF)(ReadBuffer,1);
  3016.                             else
  3017.                                 Length = 1;
  3018.  
  3019.                             if(Length)
  3020.                             {
  3021.                                 TranslateSetup(&Handle,ReadBuffer,Length,&Temp,1,ReceiveTable);
  3022.  
  3023.                                 while(!Done && TranslateBuffer(&Handle))
  3024.                                 {
  3025.                                     switch(Temp)
  3026.                                     {
  3027.                                         case '\n':
  3028.  
  3029.                                             break;
  3030.  
  3031.                                         case '\r':
  3032.  
  3033.                                             Done = TRUE;
  3034.  
  3035.                                             if(Echo)
  3036.                                                 SerWrite(&Temp,1);
  3037.  
  3038.                                             break;
  3039.  
  3040.                                         case '\b':
  3041.  
  3042.                                             if(Index > 0)
  3043.                                             {
  3044.                                                 Index--;
  3045.  
  3046.                                                 if(Echo)
  3047.                                                     SerWrite(&Temp,1);
  3048.                                             }
  3049.  
  3050.                                             break;
  3051.  
  3052.                                         case '\30':
  3053.  
  3054.                                             if(Echo)
  3055.                                             {
  3056.                                                 while(Index > 0)
  3057.                                                 {
  3058.                                                     Index--;
  3059.  
  3060.                                                     SerWrite("\b",1);
  3061.                                                 }
  3062.                                             }
  3063.                                             else
  3064.                                                 Index = 0;
  3065.  
  3066.                                         default:
  3067.  
  3068.                                             if(Index < Len && ((Temp >= ' ' && Temp < 127) || Temp >= 160 || Config -> TerminalConfig -> FontMode == FONT_IBM))
  3069.                                             {
  3070.                                                 Buffer[Index++] = Temp;
  3071.  
  3072.                                                 if(Echo)
  3073.                                                     SerWrite(&Temp,1);
  3074.                                             }
  3075.  
  3076.                                             break;
  3077.                                     }
  3078.                                 }
  3079.                             }
  3080.                         }
  3081.  
  3082.                         RestartSerial();
  3083.                     }
  3084.  
  3085.                     if(Signals & (SIG_BREAK | SIG_TIMER))
  3086.                     {
  3087.                         Results[0] = RC_WARN;
  3088.  
  3089.                         break;
  3090.                     }
  3091.  
  3092.                     if(!Done)
  3093.                         Signals = Wait(SignalMask | SIG_WINDOW);
  3094.                 }
  3095.                 while(!Done);
  3096.  
  3097.                 if(RexxTimeoutVal)
  3098.                     StopTime();
  3099.  
  3100.                 if(Index)
  3101.                 {
  3102.                     STRPTR Result;
  3103.  
  3104.                     Buffer[Index] = 0;
  3105.  
  3106.                     Result = CreateResult(Buffer,Results);
  3107.  
  3108.                     if(Args[ARG_READ_CR])
  3109.                     {
  3110.                         Forbid();
  3111.  
  3112.                         Window -> Flags &= ~WFLG_RMBTRAP;
  3113.  
  3114.                         LT_LockWindow(Window);
  3115.  
  3116.                         Permit();
  3117.                     }
  3118.  
  3119.                     ReleaseWindows();
  3120.  
  3121.                     FreeVecPooled(Buffer);
  3122.  
  3123.                     return(Result);
  3124.                 }
  3125.                 else
  3126.                     Results[0] = RC_WARN;
  3127.  
  3128.                 FreeVecPooled(Buffer);
  3129.             }
  3130.             else
  3131.             {
  3132.                 Results[0] = RC_ERROR;
  3133.                 Results[1] = ERROR_NO_FREE_STORE;
  3134.             }
  3135.         }
  3136.         else
  3137.         {
  3138.             STRPTR Buffer;
  3139.  
  3140.             if(Buffer = (STRPTR)AllocVecPooled(Len,MEMF_ANY))
  3141.             {
  3142.                 STRPTR Result;
  3143.  
  3144.                 if(DataHold && DataSize >= Len - 1)
  3145.                 {
  3146.                     CopyMem(DataHold,Buffer,Len - 1);
  3147.  
  3148.                     BytesRead = Len - 1;
  3149.  
  3150.                     if(DataSize == Len - 1)
  3151.                     {
  3152.                         DataHold = NULL;
  3153.  
  3154.                         RestartSerial();
  3155.                     }
  3156.                     else
  3157.                     {
  3158.                         DataHold += Len - 1;
  3159.                         DataSize -= Len - 1;
  3160.                     }
  3161.                 }
  3162.                 else
  3163.                 {
  3164.                     ULONG Signals,SignalMask = SIG_SERIAL | SIG_TIMER | SIG_BREAK;
  3165.  
  3166.                     ClearSerial();
  3167.  
  3168.                     ClrSignal(SignalMask);
  3169.  
  3170.                     if(RexxTimeoutVal)
  3171.                         StartTime(RexxTimeoutVal,0);
  3172.  
  3173.                     if(DataHold)
  3174.                     {
  3175.                         CopyMem(DataHold,Buffer,DataSize);
  3176.  
  3177.                         StartSerialRead(Buffer + DataSize,Len - 1 - DataSize);
  3178.  
  3179.                         BytesRead = DataSize;
  3180.  
  3181.                         DataHold = NULL;
  3182.                     }
  3183.                     else
  3184.                         StartSerialRead(Buffer,Len - 1);
  3185.  
  3186.                     FOREVER
  3187.                     {
  3188.                         Signals = Wait(SignalMask);
  3189.  
  3190.                         if(Signals & SIG_SERIAL)
  3191.                         {
  3192.                             if(RexxTimeoutVal)
  3193.                                 StopTime();
  3194.  
  3195.                                 /* Did the request terminate gracefully? */
  3196.  
  3197.                             if(!WaitSerialRead())
  3198.                             {
  3199.                                 BytesIn += ReadRequest -> IOSer . io_Actual;
  3200.  
  3201.                                 BytesRead = ReadRequest -> IOSer . io_Actual;
  3202.                             }
  3203.                             else
  3204.                                 Results[0] = RC_ERROR;
  3205.  
  3206.                             break;
  3207.                         }
  3208.  
  3209.                         if(Signals & SIG_BREAK)
  3210.                         {
  3211.                             StopSerialRead();
  3212.  
  3213.                             if(RexxTimeoutVal)
  3214.                                 StopTime();
  3215.  
  3216.                             Results[0] = RC_WARN;
  3217.  
  3218.                             break;
  3219.                         }
  3220.  
  3221.                         if(Signals & SIG_TIMER)
  3222.                         {
  3223.                             StopSerialRead();
  3224.  
  3225.                             WaitIO(TimeRequest);
  3226.  
  3227.                             if(ReadRequest -> IOSer . io_Actual)
  3228.                             {
  3229.                                 BytesIn += ReadRequest -> IOSer . io_Actual;
  3230.  
  3231.                                 BytesRead = ReadRequest -> IOSer . io_Actual;
  3232.                             }
  3233.                             else
  3234.                             {
  3235.                                 ULONG Waiting = GetSerialWaiting();
  3236.  
  3237.                                 if(Waiting)
  3238.                                 {
  3239.                                         /* Don't read more than actually wanted. */
  3240.  
  3241.                                     if(!DoSerialRead(Buffer,MIN(Len - 1,Waiting)))
  3242.                                     {
  3243.                                         BytesIn += ReadRequest -> IOSer . io_Actual;
  3244.  
  3245.                                         BytesRead = ReadRequest -> IOSer . io_Actual;
  3246.                                     }
  3247.                                 }
  3248.                             }
  3249.  
  3250.                             break;
  3251.                         }
  3252.                     }
  3253.                 }
  3254.  
  3255.                 if(BytesRead)
  3256.                 {
  3257.                     STRPTR MetaBuffer;
  3258.  
  3259.                     if(MetaBuffer = AllocVecPooled(Len,MEMF_ANY))
  3260.                     {
  3261.                         struct TranslationHandle    Handle;
  3262.                         LONG                Bytes;
  3263.  
  3264.                         TranslateSetup(&Handle,Buffer,BytesRead,MetaBuffer,Len - 1,ReceiveTable);
  3265.  
  3266.                         Bytes = TranslateBuffer(&Handle);
  3267.  
  3268.                         Result = CreateResultLen(MetaBuffer,Results,Bytes);
  3269.  
  3270.                         FreeVecPooled(MetaBuffer);
  3271.                     }
  3272.                     else
  3273.                     {
  3274.                         Results[0] = RC_ERROR;
  3275.                         Results[1] = ERROR_NO_FREE_STORE;
  3276.  
  3277.                         Result = NULL;
  3278.                     }
  3279.                 }
  3280.                 else
  3281.                 {
  3282.                     Results[0] = RC_WARN;
  3283.  
  3284.                     Result = NULL;
  3285.                 }
  3286.  
  3287.                 FreeVecPooled(Buffer);
  3288.  
  3289.                 RestartSerial();
  3290.  
  3291.                 if(Args[ARG_READ_CR])
  3292.                 {
  3293.                     Forbid();
  3294.  
  3295.                     Window -> Flags &= ~WFLG_RMBTRAP;
  3296.  
  3297.                     LT_LockWindow(Window);
  3298.  
  3299.                     Permit();
  3300.                 }
  3301.  
  3302.                 ReleaseWindows();
  3303.  
  3304.                 return(Result);
  3305.             }
  3306.             else
  3307.             {
  3308.                 Results[0] = RC_ERROR;
  3309.                 Results[1] = ERROR_NO_FREE_STORE;
  3310.             }
  3311.  
  3312.             RestartSerial();
  3313.         }
  3314.     }
  3315.  
  3316.     if(Args[ARG_READ_CR])
  3317.     {
  3318.         Forbid();
  3319.  
  3320.         Window -> Flags &= ~WFLG_RMBTRAP;
  3321.  
  3322.         LT_LockWindow(Window);
  3323.  
  3324.         Permit();
  3325.     }
  3326.  
  3327.     ReleaseWindows();
  3328.  
  3329.     return(NULL);
  3330. }
  3331.  
  3332. STRPTR
  3333. RexxReceiveFile(struct RexxPkt *Pkt)
  3334. {
  3335.     enum    {    ARG_RECEIVEFILE_MODE,ARG_RECEIVEFILE_NAME };
  3336.  
  3337.     WORD    Mode = TRANSFER_BINARY;
  3338.     STRPTR    Name = (STRPTR)Args[ARG_RECEIVEFILE_NAME];
  3339.  
  3340.     if(Args[ARG_RECEIVEFILE_MODE])
  3341.         Mode = ToMode(Args[ARG_RECEIVEFILE_MODE]);
  3342.  
  3343.     if(Mode == -1)
  3344.     {
  3345.         Results[0] = RC_ERROR;
  3346.         Results[1] = ERROR_ACTION_NOT_KNOWN;
  3347.     }
  3348.     else
  3349.     {
  3350.         BlockWindows();
  3351.  
  3352.         switch(Mode)
  3353.         {
  3354.             case TRANSFER_ASCII:
  3355.  
  3356.                 if(ChangeProtocol(Config -> TransferConfig -> ASCIIDownloadLibrary,Config -> TransferConfig -> ASCIIDownloadType))
  3357.                 {
  3358.                     BinaryTransfer = FALSE;
  3359.  
  3360.                     StartXprReceive(TRANSFER_ASCII,Name,FALSE);
  3361.  
  3362.                     BinaryTransfer = TRUE;
  3363.  
  3364.                     SerialCommand(Config -> CommandConfig -> DownloadMacro);
  3365.                 }
  3366.                 else
  3367.                 {
  3368.                     Results[0] = RC_ERROR;
  3369.                     Results[1] = ERROR_NO_FREE_STORE;
  3370.                 }
  3371.  
  3372.                 ResetProtocol();
  3373.  
  3374.                 break;
  3375.  
  3376.             case TRANSFER_TEXT:
  3377.  
  3378.                 if(ChangeProtocol(Config -> TransferConfig -> TextDownloadLibrary,Config -> TransferConfig -> TextDownloadType))
  3379.                 {
  3380.                     BinaryTransfer = FALSE;
  3381.  
  3382.                     StartXprReceive(TRANSFER_TEXT,Name,FALSE);
  3383.  
  3384.                     BinaryTransfer = TRUE;
  3385.  
  3386.                     SerialCommand(Config -> CommandConfig -> DownloadMacro);
  3387.                 }
  3388.                 else
  3389.                 {
  3390.                     Results[0] = RC_ERROR;
  3391.                     Results[1] = ERROR_NO_FREE_STORE;
  3392.                 }
  3393.  
  3394.                 ResetProtocol();
  3395.  
  3396.                 break;
  3397.  
  3398.             case TRANSFER_BINARY:
  3399.  
  3400.                 if(ChangeProtocol(Config -> TransferConfig -> BinaryDownloadLibrary,Config -> TransferConfig -> BinaryDownloadType))
  3401.                 {
  3402.                     BinaryTransfer = TRUE;
  3403.  
  3404.                     StartXprReceive(TRANSFER_BINARY,Name,FALSE);
  3405.  
  3406.                     SerialCommand(Config -> CommandConfig -> DownloadMacro);
  3407.                 }
  3408.                 else
  3409.                 {
  3410.                     Results[0] = RC_ERROR;
  3411.                     Results[1] = ERROR_NO_FREE_STORE;
  3412.                 }
  3413.  
  3414.                 ResetProtocol();
  3415.  
  3416.                 break;
  3417.         }
  3418.  
  3419.         if(TransferFailed)
  3420.             Results[0] = RC_ERROR;
  3421.  
  3422.         if(TransferAborted)
  3423.             Results[0] = RC_WARN;
  3424.  
  3425.         ReleaseWindows();
  3426.     }
  3427.  
  3428.     return(NULL);
  3429. }
  3430.  
  3431. STRPTR
  3432. RexxRedial(struct RexxPkt *Pkt)
  3433. {
  3434.     if(DialList)
  3435.     {
  3436.         if(DialList -> lh_Head -> ln_Succ)
  3437.             DoDial = DIAL_REDIAL;
  3438.         else
  3439.             Results[0] = RC_WARN;
  3440.     }
  3441.     else
  3442.         Results[0] = RC_WARN;
  3443.  
  3444.     return(NULL);
  3445. }
  3446.  
  3447. STRPTR
  3448. RexxRemove(struct RexxPkt *Pkt)
  3449. {
  3450.     enum    {    ARG_REMOVE_FROM,ARG_REMOVE_NAME };
  3451.  
  3452.     WORD Index;
  3453.  
  3454.     if((Index = ToList(Args[ARG_REMOVE_FROM])) == -1)
  3455.     {
  3456.         Results[0] = RC_ERROR;
  3457.         Results[1] = TERMERROR_UNKNOWN_LIST;
  3458.     }
  3459.     else
  3460.     {
  3461.         if(Args[ARG_REMOVE_NAME] && Index == GLIST_DIAL)
  3462.         {
  3463.             Results[0] = RC_ERROR;
  3464.             Results[1] = TERMERROR_DATA_TYPES_INCOMPATIBLE;
  3465.         }
  3466.         else
  3467.         {
  3468.             struct GenericList *List;
  3469.  
  3470.             List = GenericListTable[Index];
  3471.  
  3472.             if(Args[ARG_REMOVE_NAME])
  3473.             {
  3474.                 STRPTR Buffer;
  3475.  
  3476.                 if(Buffer = CreateMatchBuffer(Args[ARG_REMOVE_NAME]))
  3477.                 {
  3478.                     struct Node *Node,*NextNode;
  3479.  
  3480.                     ObtainSemaphore(&List -> ListSemaphore);
  3481.  
  3482.                     Node = (struct Node *)List -> ListHeader . mlh_Head;
  3483.  
  3484.                     while(NextNode = Node -> ln_Succ)
  3485.                     {
  3486.                         if(MatchBuffer(Buffer,Node -> ln_Name))
  3487.                         {
  3488.                             Forbid();
  3489.  
  3490.                             ReleaseSemaphore(&List -> ListSemaphore);
  3491.  
  3492.                             DeleteGenericListNode(List,Node);
  3493.  
  3494.                             ObtainSemaphore(&List -> ListSemaphore);
  3495.  
  3496.                             Permit();
  3497.                         }
  3498.  
  3499.                         Node = NextNode;
  3500.                     }
  3501.  
  3502.                     ReleaseSemaphore(&List -> ListSemaphore);
  3503.  
  3504.                     DeleteMatchBuffer(Buffer);
  3505.                 }
  3506.                 else
  3507.                 {
  3508.                     Results[0] = RC_ERROR;
  3509.                     Results[1] = ERROR_NO_FREE_STORE;
  3510.                 }
  3511.             }
  3512.             else
  3513.                 DeleteGenericListNode(List,NULL);
  3514.  
  3515.             if(!GenericListCount(List))
  3516.                 Results[0] = RC_WARN;
  3517.         }
  3518.     }
  3519.  
  3520.     return(NULL);
  3521. }
  3522.  
  3523. STRPTR
  3524. RexxRequestFile(struct RexxPkt *Pkt)
  3525. {
  3526.     enum    {    ARG_REQUESTFILE_TITLE,ARG_REQUESTFILE_PATH,ARG_REQUESTFILE_FILE,
  3527.             ARG_REQUESTFILE_PATTERN,ARG_REQUESTFILE_MULTI,ARG_REQUESTFILE_NAME };
  3528.  
  3529.     if(Args[ARG_REQUESTFILE_MULTI] && !Args[ARG_REQUESTFILE_NAME])
  3530.     {
  3531.         Results[0] = RC_ERROR;
  3532.         Results[1] = TERMERROR_RESULT_VARIABLE_REQUIRED;
  3533.     }
  3534.     else
  3535.     {
  3536.         struct FileRequester    *FileRequester;
  3537.         UBYTE             DummyBuffer[MAX_FILENAME_LENGTH],
  3538.                     *DummyChar;
  3539.         STRPTR             FileName,
  3540.                      PathName;
  3541.  
  3542.         if(Args[ARG_REQUESTFILE_PATH])
  3543.         {
  3544.             PathName = Args[ARG_REQUESTFILE_PATH];
  3545.  
  3546.             if(Args[ARG_REQUESTFILE_FILE])
  3547.                 FileName = Args[ARG_REQUESTFILE_FILE];
  3548.             else
  3549.                 FileName = "";
  3550.         }
  3551.         else
  3552.         {
  3553.             PathName = "";
  3554.  
  3555.             if(Args[ARG_REQUESTFILE_FILE])
  3556.             {
  3557.                 strcpy(DummyBuffer,Args[ARG_REQUESTFILE_FILE]);
  3558.  
  3559.                 DummyChar = PathPart(DummyBuffer);
  3560.  
  3561.                 *DummyChar = 0;
  3562.  
  3563.                 PathName = DummyBuffer;
  3564.                 FileName = FilePart(Args[ARG_REQUESTFILE_FILE]);
  3565.             }
  3566.             else
  3567.                 FileName = "";
  3568.         }
  3569.  
  3570.         BlockWindows();
  3571.  
  3572.         if(FileRequester = GetFile(Window,Args[ARG_REQUESTFILE_TITLE],PathName,FileName,DummyBuffer,Args[ARG_REQUESTFILE_PATTERN],FALSE,Args[ARG_REQUESTFILE_MULTI] != NULL,FALSE,"Ok",TRUE))
  3573.         {
  3574.             if(Args[ARG_REQUESTFILE_NAME])
  3575.             {
  3576.                 if(Args[ARG_REQUESTFILE_MULTI])
  3577.                 {
  3578.                     UBYTE         DummyBuffer[MAX_FILENAME_LENGTH];
  3579.                     struct WBArg    *ArgList = FileRequester -> fr_ArgList;
  3580.                     LONG         i,Counted = 0;
  3581.  
  3582.                     for(i = 0 ; i < FileRequester -> fr_NumArgs ; i++)
  3583.                     {
  3584.                         if(ArgList[i] . wa_Name)
  3585.                         {
  3586.                             if(ArgList[i] . wa_Lock)
  3587.                             {
  3588.                                 if(!NameFromLock(ArgList[i] . wa_Lock,DummyBuffer,MAX_FILENAME_LENGTH))
  3589.                                 {
  3590.                                     Results[0] = RC_ERROR;
  3591.                                     Results[1] = IoErr();
  3592.  
  3593.                                     break;
  3594.                                 }
  3595.                             }
  3596.                             else
  3597.                                 strcpy(DummyBuffer,FileRequester -> fr_Drawer);
  3598.  
  3599.                             if(AddPart(DummyBuffer,ArgList[i] . wa_Name,MAX_FILENAME_LENGTH))
  3600.                             {
  3601.                                 if(CreateVarArgs(DummyBuffer,Pkt,"%s.%ld",Args[ARG_REQUESTFILE_NAME],i))
  3602.                                     Counted++;
  3603.                                 else
  3604.                                     break;
  3605.                             }
  3606.                             else
  3607.                             {
  3608.                                 Results[0] = RC_ERROR;
  3609.                                 Results[1] = IoErr();
  3610.  
  3611.                                 break;
  3612.                             }
  3613.                         }
  3614.                     }
  3615.  
  3616.                     if(Counted)
  3617.                     {
  3618.                         SPrintf(DummyBuffer,"%ld",Counted);
  3619.  
  3620.                         CreateVarArgs(DummyBuffer,Pkt,"%s.COUNT",Args[ARG_REQUESTFILE_NAME]);
  3621.                     }
  3622.  
  3623.                     FreeAslRequest(FileRequester);
  3624.                 }
  3625.                 else
  3626.                 {
  3627.                     FreeAslRequest(FileRequester);
  3628.  
  3629.                     ReleaseWindows();
  3630.  
  3631.                     return(CreateVar(DummyBuffer,Pkt,Args[ARG_REQUESTFILE_NAME]));
  3632.                 }
  3633.             }
  3634.             else
  3635.             {
  3636.                 FreeAslRequest(FileRequester);
  3637.  
  3638.                 ReleaseWindows();
  3639.  
  3640.                 return(CreateResult(DummyBuffer,Results));
  3641.             }
  3642.         }
  3643.         else
  3644.             Results[0] = RC_WARN;
  3645.  
  3646.         ReleaseWindows();
  3647.     }
  3648.  
  3649.     return(NULL);
  3650. }
  3651.  
  3652. STRPTR
  3653. RexxRequestNotify(struct RexxPkt *Pkt)
  3654. {
  3655.     enum    {    ARG_REQUESTNOTIFY_TITLE,ARG_REQUESTNOTIFY_PROMPT };
  3656.  
  3657.     struct EasyStruct    Easy;
  3658.     ULONG            IDCMP = NULL;
  3659.  
  3660.     Easy . es_StructSize    = sizeof(struct EasyStruct);
  3661.     Easy . es_Flags        = NULL;
  3662.     Easy . es_TextFormat    = Args[ARG_REQUESTNOTIFY_PROMPT];
  3663.     Easy . es_GadgetFormat    = LocaleString(MSG_GLOBAL_CONTINUE_TXT);
  3664.  
  3665.     if(Args[ARG_REQUESTNOTIFY_TITLE])
  3666.         Easy . es_Title    = Args[ARG_REQUESTNOTIFY_TITLE];
  3667.     else
  3668.         Easy . es_Title    = LocaleString(MSG_TERMAUX_TERM_REQUEST_TXT);
  3669.  
  3670.     BlockWindows();
  3671.  
  3672.     EasyRequestArgs(Window,&Easy,&IDCMP,NULL);
  3673.  
  3674.     ReleaseWindows();
  3675.  
  3676.     return(NULL);
  3677. }
  3678.  
  3679. STRPTR
  3680. RexxRequestNumber(struct RexxPkt *Pkt)
  3681. {
  3682.     enum    {    ARG_REQUESTNUMBER_DEFAULT,ARG_REQUESTNUMBER_PROMPT };
  3683.  
  3684.     UBYTE DummyBuffer[MAX_FILENAME_LENGTH];
  3685.  
  3686.     if(Args[ARG_REQUESTNUMBER_DEFAULT])
  3687.         SPrintf(DummyBuffer,"%ld",*(LONG *)Args[ARG_REQUESTNUMBER_DEFAULT]);
  3688.     else
  3689.         DummyBuffer[0] = 0;
  3690.  
  3691.     BlockWindows();
  3692.  
  3693.     if(GetString(FALSE,FALSE,255,Args[ARG_REQUESTNUMBER_PROMPT],DummyBuffer))
  3694.     {
  3695.         STRPTR Index = DummyBuffer;
  3696.  
  3697.         while(*Index == ' ' || *Index == '\t')
  3698.             Index++;
  3699.  
  3700.         if(*Index)
  3701.         {
  3702.             LONG Value;
  3703.  
  3704.             if(StrToLong(DummyBuffer,&Value) == -1)
  3705.             {
  3706.                 Results[0] = RC_ERROR;
  3707.                 Results[1] = ERROR_BAD_NUMBER;
  3708.             }
  3709.             else
  3710.             {
  3711.                 ReleaseWindows();
  3712.  
  3713.                 SPrintf(DummyBuffer,"%ld",Value);
  3714.  
  3715.                 return(CreateResult(DummyBuffer,Results));
  3716.             }
  3717.         }
  3718.         else
  3719.             Results[0] = RC_WARN;
  3720.     }
  3721.     else
  3722.         Results[0] = RC_WARN;
  3723.  
  3724.     ReleaseWindows();
  3725.  
  3726.     return(NULL);
  3727. }
  3728.  
  3729. STRPTR
  3730. RexxRequestResponse(struct RexxPkt *Pkt)
  3731. {
  3732.     enum    {    ARG_REQUESTRESPONSE_TITLE,ARG_REQUESTRESPONSE_OPTIONS,
  3733.             ARG_REQUESTRESPONSE_PROMPT };
  3734.  
  3735.     struct EasyStruct    Easy;
  3736.     ULONG            IDCMP = NULL;
  3737.     WORD            Result;
  3738.  
  3739.     Easy . es_StructSize    = sizeof(struct EasyStruct);
  3740.     Easy . es_Flags        = NULL;
  3741.     Easy . es_TextFormat    = Args[ARG_REQUESTRESPONSE_PROMPT];
  3742.  
  3743.     if(Args[ARG_REQUESTRESPONSE_OPTIONS])
  3744.         Easy . es_GadgetFormat = Args[ARG_REQUESTRESPONSE_OPTIONS];
  3745.     else
  3746.         Easy . es_GadgetFormat = LocaleString(MSG_GLOBAL_YES_NO_TXT);
  3747.  
  3748.     if(Args[ARG_REQUESTRESPONSE_TITLE])
  3749.         Easy . es_Title    = Args[ARG_REQUESTRESPONSE_TITLE];
  3750.     else
  3751.         Easy . es_Title    = LocaleString(MSG_TERMAUX_TERM_REQUEST_TXT);
  3752.  
  3753.     BlockWindows();
  3754.  
  3755.     Result = EasyRequestArgs(Window,&Easy,&IDCMP,NULL);
  3756.  
  3757.     ReleaseWindows();
  3758.  
  3759.     if(Result)
  3760.     {
  3761.         UBYTE DummyBuffer[20];
  3762.  
  3763.         SPrintf(DummyBuffer,"%ld",Result);
  3764.  
  3765.         return(CreateResult(DummyBuffer,Results));
  3766.     }
  3767.     else
  3768.     {
  3769.         Results[0] = RC_WARN;
  3770.  
  3771.         return(NULL);
  3772.     }
  3773. }
  3774.  
  3775. STRPTR
  3776. RexxRequestString(struct RexxPkt *Pkt)
  3777. {
  3778.     enum    {    ARG_REQUESTSTRING_SECRET,ARG_REQUESTSTRING_DEFAULT,ARG_REQUESTSTRING_PROMPT };
  3779.  
  3780.     UBYTE DummyBuffer[MAX_FILENAME_LENGTH];
  3781.  
  3782.     if(Args[ARG_REQUESTSTRING_DEFAULT])
  3783.         strcpy(DummyBuffer,Args[ARG_REQUESTSTRING_DEFAULT]);
  3784.     else
  3785.         DummyBuffer[0] = 0;
  3786.  
  3787.     BlockWindows();
  3788.  
  3789.     if(GetString(FALSE,Args[ARG_REQUESTSTRING_SECRET] != NULL,255,Args[ARG_REQUESTSTRING_PROMPT],DummyBuffer))
  3790.     {
  3791.         ReleaseWindows();
  3792.  
  3793.         return(CreateResult(DummyBuffer,Results));
  3794.     }
  3795.     else
  3796.         Results[0] = RC_WARN;
  3797.  
  3798.     ReleaseWindows();
  3799.  
  3800.     return(NULL);
  3801. }
  3802.  
  3803. STRPTR
  3804. RexxResetScreen(struct RexxPkt *Pkt)
  3805. {
  3806.     if(XEmulatorBase && Config -> TerminalConfig -> EmulationMode == EMULATION_EXTERNAL)
  3807.         XEmulatorResetConsole(XEM_IO);
  3808.     else
  3809.     {
  3810.         FreeMarker();
  3811.  
  3812.         ObtainSemaphore(&TerminalSemaphore);
  3813.  
  3814.         ClearCursor();
  3815.  
  3816.         Reset();
  3817.  
  3818.         DrawCursor();
  3819.  
  3820.         ReleaseSemaphore(&TerminalSemaphore);
  3821.     }
  3822.  
  3823.     return(NULL);
  3824. }
  3825.  
  3826. STRPTR
  3827. RexxResetStyles(struct RexxPkt *Pkt)
  3828. {
  3829.     if(XEmulatorBase && Config -> TerminalConfig -> EmulationMode == EMULATION_EXTERNAL)
  3830.         XEmulatorResetTextStyles(XEM_IO);
  3831.     else
  3832.     {
  3833.         DropMarker();
  3834.  
  3835.         ConBypass("\033[0m",-1);
  3836.  
  3837.         ObtainSemaphore(&TerminalSemaphore);
  3838.  
  3839.         ClearCursor();
  3840.  
  3841.         Config -> EmulationConfig -> FontScale = SCALE_NORMAL;
  3842.  
  3843.         ForegroundPen = GetPenIndex(SafeTextPen);
  3844.         BackgroundPen = 0;
  3845.  
  3846.         UpdatePens();
  3847.  
  3848.         SetMask(RPort,DepthMask);
  3849.  
  3850.         ConFontScaleUpdate();
  3851.  
  3852.         DrawCursor();
  3853.  
  3854.         ReleaseSemaphore(&TerminalSemaphore);
  3855.     }
  3856.  
  3857.     return(NULL);
  3858. }
  3859.  
  3860. STRPTR
  3861. RexxResetText(struct RexxPkt *Pkt)
  3862. {
  3863.     if(XEmulatorBase && Config -> TerminalConfig -> EmulationMode == EMULATION_EXTERNAL)
  3864.         XEmulatorResetCharset(XEM_IO);
  3865.     else
  3866.     {
  3867.         DropMarker();
  3868.  
  3869.         CurrentFont = TextFont;
  3870.  
  3871.         SetFont(RPort,CurrentFont);
  3872.  
  3873.         ConOutputUpdate();
  3874.     }
  3875.  
  3876.     return(NULL);
  3877. }
  3878.  
  3879. STRPTR
  3880. RexxResetTimer(struct RexxPkt *Pkt)
  3881. {
  3882.     Forbid();
  3883.  
  3884.     if(StatusProcess)
  3885.         Signal(StatusProcess,SIG_RESETTIME);
  3886.  
  3887.     Permit();
  3888.  
  3889.     return(NULL);
  3890. }
  3891.  
  3892. STRPTR
  3893. RexxSaveAs(struct RexxPkt *Pkt)
  3894. {
  3895.     enum    {    ARG_SAVEAS_NAME,ARG_SAVEAS_FROM };
  3896.  
  3897.     WORD Index = ToConfig(Args[ARG_SAVEAS_FROM]);
  3898.  
  3899.     if(Index == -1)
  3900.     {
  3901.         Results[0] = RC_ERROR;
  3902.         Results[1] = ERROR_OBJECT_NOT_FOUND;
  3903.     }
  3904.     else
  3905.     {
  3906.         UBYTE    DummyBuffer[MAX_FILENAME_LENGTH];
  3907.         STRPTR    FileName;
  3908.  
  3909.         if(Args[ARG_SAVEAS_NAME])
  3910.             FileName = Args[ARG_SAVEAS_NAME];
  3911.         else
  3912.         {
  3913.             STRPTR             Title;
  3914.             struct FileRequester    *FileRequest;
  3915.  
  3916.             FileName = NULL;
  3917.  
  3918.             switch(Index)
  3919.             {
  3920.                 case DATATYPE_TRANSLATIONS:
  3921.  
  3922.                     Title = LocaleString(MSG_TRANSLATIONPANEL_SAVE_TRANSLATION_TABLES_TXT);
  3923.                     break;
  3924.  
  3925.                 case DATATYPE_FUNCTIONKEYS:
  3926.  
  3927.                     Title = LocaleString(MSG_MACROPANEL_SAVE_MACRO_KEYS_TXT);
  3928.                     break;
  3929.  
  3930.                 case DATATYPE_CURSORKEYS:
  3931.  
  3932.                     Title = LocaleString(MSG_CURSORPANEL_SAVE_CURSOR_KEYS_TXT);
  3933.                     break;
  3934.  
  3935.                 case DATATYPE_FASTMACROS:
  3936.  
  3937.                     Title = LocaleString(MSG_FASTMACROPANEL_SAVE_FAST_MACRO_SETTINGS_TXT);
  3938.                     break;
  3939.  
  3940.                 case DATATYPE_HOTKEYS:
  3941.  
  3942.                     Title = LocaleString(MSG_HOTKEYPANEL_SAVE_HOTKEYS_TXT);
  3943.                     break;
  3944.  
  3945.                 case DATATYPE_SPEECH:
  3946.  
  3947.                     Title = LocaleString(MSG_SPEECHPANEL_SAVE_SPEECH_SETTINGS_TXT);
  3948.                     break;
  3949.  
  3950.                 case DATATYPE_SOUND:
  3951.  
  3952.                     Title = LocaleString(MSG_SOUNDPANEL_SAVE_SOUNDS_TXT);
  3953.                     break;
  3954.  
  3955.                 case DATATYPE_BUFFER:
  3956.  
  3957.                     Title = LocaleString(MSG_TERMMAIN_SAVE_BUFFER_TXT);
  3958.                     break;
  3959.  
  3960.                 case DATATYPE_CONFIGURATION:
  3961.  
  3962.                     Title = LocaleString(MSG_TERMMAIN_SAVE_PREFERENCES_AS_TXT);
  3963.                     break;
  3964.  
  3965.                 case DATATYPE_PHONEBOOK:
  3966.  
  3967.                     Title = LocaleString(MSG_PHONEPANEL_SAVE_PHONEBOOK_TXT);
  3968.                     break;
  3969.  
  3970.                 case DATATYPE_SCREENTEXT:
  3971.  
  3972.                     Title = LocaleString(MSG_TERMMAIN_SAVE_SCREEN_ASCII_TXT);
  3973.                     break;
  3974.  
  3975.                 case DATATYPE_SCREENIMAGE:
  3976.  
  3977.                     Title = LocaleString(MSG_TERMMAIN_SAVE_SCREEN_IFF_TXT);
  3978.                     break;
  3979.             }
  3980.  
  3981.             BlockWindows();
  3982.  
  3983.             if(FileRequest = GetFile(Window,Title,"","",DummyBuffer,NULL,TRUE,FALSE,FALSE,NULL,TRUE))
  3984.             {
  3985.                 FileName = DummyBuffer;
  3986.  
  3987.                 FreeAslRequest(FileRequest);
  3988.             }
  3989.  
  3990.             ReleaseWindows();
  3991.         }
  3992.  
  3993.         if(FileName)
  3994.         {
  3995.             switch(Index)
  3996.             {
  3997.                 case DATATYPE_TRANSLATIONS:
  3998.                 {
  3999.                     if(SendTable && ReceiveTable)
  4000.                     {
  4001.                         if(!SaveTranslationTables(FileName,SendTable,ReceiveTable))
  4002.                         {
  4003.                             Results[0] = RC_ERROR;
  4004.                             Results[1] = IoErr();
  4005.                         }
  4006.                         else
  4007.                         {
  4008.                             strcpy(LastTranslation,FileName);
  4009.  
  4010.                             TranslationChanged = FALSE;
  4011.                         }
  4012.                     }
  4013.                     else
  4014.                         Results[0] = RC_WARN;
  4015.                 }
  4016.  
  4017.                 break;
  4018.  
  4019.                 case DATATYPE_FUNCTIONKEYS:
  4020.                 {
  4021.                     if(!WriteIFFData(FileName,MacroKeys,sizeof(struct MacroKeys),ID_KEYS))
  4022.                     {
  4023.                         Results[0] = RC_ERROR;
  4024.                         Results[1] = IoErr();
  4025.                     }
  4026.                     else
  4027.                     {
  4028.                         strcpy(LastMacros,FileName);
  4029.  
  4030.                         MacroChanged = FALSE;
  4031.                     }
  4032.                 }
  4033.  
  4034.                 break;
  4035.  
  4036.                 case DATATYPE_CURSORKEYS:
  4037.                 {
  4038.                     if(!WriteIFFData(FileName,CursorKeys,sizeof(struct CursorKeys),ID_KEYS))
  4039.                     {
  4040.                         Results[0] = RC_ERROR;
  4041.                         Results[1] = IoErr();
  4042.                     }
  4043.                     else
  4044.                     {
  4045.                         strcpy(LastCursorKeys,FileName);
  4046.  
  4047.                         CursorKeysChanged = FALSE;
  4048.                     }
  4049.                 }
  4050.  
  4051.                 break;
  4052.  
  4053.                 case DATATYPE_FASTMACROS:
  4054.                 {
  4055.                     if(!SaveFastMacros(FileName,&FastMacroList))
  4056.                     {
  4057.                         Results[0] = RC_ERROR;
  4058.                         Results[1] = IoErr();
  4059.                     }
  4060.                     else
  4061.                     {
  4062.                         strcpy(LastFastMacros,FileName);
  4063.  
  4064.                         FastMacrosChanged = FALSE;
  4065.                     }
  4066.                 }
  4067.  
  4068.                 break;
  4069.  
  4070.                 case DATATYPE_HOTKEYS:
  4071.                 {
  4072.                     if(!WriteIFFData(FileName,&Hotkeys,sizeof(struct Hotkeys),ID_HOTK))
  4073.                     {
  4074.                         Results[0] = RC_ERROR;
  4075.                         Results[1] = IoErr();
  4076.                     }
  4077.                     else
  4078.                     {
  4079.                         strcpy(LastKeys,FileName);
  4080.  
  4081.                         HotkeysChanged = FALSE;
  4082.                     }
  4083.                 }
  4084.  
  4085.                 break;
  4086.  
  4087.                 case DATATYPE_SPEECH:
  4088.                 {
  4089.                     if(!WriteIFFData(FileName,&SpeechConfig,sizeof(struct SpeechConfig),ID_SPEK))
  4090.                     {
  4091.                         Results[0] = RC_ERROR;
  4092.                         Results[1] = IoErr();
  4093.                     }
  4094.                     else
  4095.                     {
  4096.                         strcpy(LastSpeech,FileName);
  4097.  
  4098.                         SpeechChanged = FALSE;
  4099.                     }
  4100.                 }
  4101.  
  4102.                 break;
  4103.  
  4104.                 case DATATYPE_SOUND:
  4105.                 {
  4106.                     if(!WriteIFFData(FileName,&SoundConfig,sizeof(struct SoundConfig),ID_SOUN))
  4107.                     {
  4108.                         Results[0] = RC_ERROR;
  4109.                         Results[1] = IoErr();
  4110.                     }
  4111.                     else
  4112.                     {
  4113.                         strcpy(LastSound,FileName);
  4114.  
  4115.                         SoundChanged = FALSE;
  4116.                     }
  4117.                 }
  4118.  
  4119.                 break;
  4120.  
  4121.                 case DATATYPE_BUFFER:
  4122.                 {
  4123.                     if(BufferLines && Lines)
  4124.                     {
  4125.                         BPTR SomeFile;
  4126.  
  4127.                         if(GetFileSize(FileName))
  4128.                         {
  4129.                             if(SomeFile = Open(FileName,MODE_READWRITE))
  4130.                             {
  4131.                                 if(Seek(SomeFile,0,OFFSET_END) == -1)
  4132.                                 {
  4133.                                     Close(SomeFile);
  4134.  
  4135.                                     SomeFile = NULL;
  4136.  
  4137.                                     SetIoErr(ERROR_SEEK_ERROR);
  4138.                                 }
  4139.                             }
  4140.                         }
  4141.                         else
  4142.                             SomeFile = Open(FileName,MODE_NEWFILE);
  4143.  
  4144.                         if(SomeFile)
  4145.                         {
  4146.                             LONG i,Len;
  4147.  
  4148.                                 /* Obtain the semaphore required
  4149.                                  * to gain access to the line buffer
  4150.                                  */
  4151.  
  4152.                             ObtainSemaphore(BufferSemaphore);
  4153.  
  4154.                             for(i = 0 ; i < Lines ; i++)
  4155.                             {
  4156.                                 Len = BufferLines[i][-1];
  4157.  
  4158.                                 if(Len)
  4159.                                 {
  4160.                                     if(FWrite(SomeFile,BufferLines[i],Len,1) != 1)
  4161.                                     {
  4162.                                         Results[0] = RC_ERROR;
  4163.                                         Results[1] = IoErr();
  4164.  
  4165.                                         break;
  4166.                                     }
  4167.                                 }
  4168.  
  4169.                                 if(FPrintf(SomeFile,"\n") < 1)
  4170.                                 {
  4171.                                     Results[0] = RC_ERROR;
  4172.                                     Results[1] = IoErr();
  4173.  
  4174.                                     break;
  4175.                                 }
  4176.                             }
  4177.  
  4178.                             ReleaseSemaphore(BufferSemaphore);
  4179.  
  4180.                             Close(SomeFile);
  4181.  
  4182.                             AddProtection(FileName,FIBF_EXECUTE);
  4183.  
  4184.                             if(Config -> MiscConfig -> CreateIcons)
  4185.                                 AddIcon(FileName,FILETYPE_TEXT,TRUE);
  4186.  
  4187.                             BufferChanged = FALSE;
  4188.                         }
  4189.                         else
  4190.                         {
  4191.                             Results[0] = RC_ERROR;
  4192.                             Results[1] = IoErr();
  4193.                         }
  4194.                     }
  4195.                     else
  4196.                     {
  4197.                         Results[0] = RC_ERROR;
  4198.                         Results[1] = TERMERROR_NO_DATA_TO_PROCESS;
  4199.                     }
  4200.                 }
  4201.  
  4202.                 break;
  4203.  
  4204.                 case DATATYPE_CONFIGURATION:
  4205.                 {
  4206.                     if(!WriteConfig(FileName,Config))
  4207.                     {
  4208.                         Results[0] = RC_ERROR;
  4209.                         Results[1] = IoErr();
  4210.                     }
  4211.                     else
  4212.                     {
  4213.                         strcpy(LastConfig,FileName);
  4214.  
  4215.                         ConfigChanged = FALSE;
  4216.                     }
  4217.                 }
  4218.  
  4219.                 break;
  4220.  
  4221.                 case DATATYPE_PHONEBOOK:
  4222.                 {
  4223.                     if(!SavePhonebook(FileName))
  4224.                     {
  4225.                         Results[0] = RC_ERROR;
  4226.                         Results[1] = IoErr();
  4227.                     }
  4228.                     else
  4229.                     {
  4230.                         strcpy(LastPhone,FileName);
  4231.  
  4232.                         PhonebookChanged = FALSE;
  4233.                     }
  4234.                 }
  4235.  
  4236.                 break;
  4237.  
  4238.                 case DATATYPE_SCREENTEXT:
  4239.                 {
  4240.                     if(RasterEnabled)
  4241.                     {
  4242.                         BPTR SomeFile;
  4243.  
  4244.                         if(GetFileSize(FileName))
  4245.                         {
  4246.                             if(SomeFile = Open(FileName,MODE_READWRITE))
  4247.                             {
  4248.                                 if(Seek(SomeFile,0,OFFSET_END) == -1)
  4249.                                 {
  4250.                                     Close(SomeFile);
  4251.  
  4252.                                     SomeFile = NULL;
  4253.  
  4254.                                     SetIoErr(ERROR_SEEK_ERROR);
  4255.                                 }
  4256.                             }
  4257.                         }
  4258.                         else
  4259.                             SomeFile = Open(FileName,MODE_NEWFILE);
  4260.  
  4261.                         if(SomeFile)
  4262.                         {
  4263.                             LONG     i,j;
  4264.                             UBYTE    *Buffer;
  4265.  
  4266.                             for(i = 0 ; i < RasterHeight ; i++)
  4267.                             {
  4268.                                 Buffer = &Raster[i * RasterWidth];
  4269.  
  4270.                                 j = LastColumn;
  4271.  
  4272.                                 while(j >= 0 && Buffer[j] == ' ')
  4273.                                     j--;
  4274.  
  4275.                                 if(j >= 0)
  4276.                                 {
  4277.                                     if(!FWrite(SomeFile,Buffer,j + 1,1))
  4278.                                     {
  4279.                                         Results[0] = RC_ERROR;
  4280.                                         Results[1] = IoErr();
  4281.  
  4282.                                         break;
  4283.                                     }
  4284.                                 }
  4285.  
  4286.                                 if(!FWrite(SomeFile,"\n",1,1))
  4287.                                 {
  4288.                                     Results[0] = RC_ERROR;
  4289.                                     Results[1] = IoErr();
  4290.  
  4291.                                     break;
  4292.                                 }
  4293.                             }
  4294.  
  4295.                             Close(SomeFile);
  4296.  
  4297.                             AddProtection(FileName,FIBF_EXECUTE);
  4298.  
  4299.                             if(Config -> MiscConfig -> CreateIcons)
  4300.                                 AddIcon(FileName,FILETYPE_TEXT,TRUE);
  4301.                         }
  4302.                         else
  4303.                         {
  4304.                             Results[0] = RC_ERROR;
  4305.                             Results[1] = IoErr();
  4306.                         }
  4307.                     }
  4308.                     else
  4309.                     {
  4310.                         Results[0] = RC_ERROR;
  4311.                         Results[1] = TERMERROR_NO_DATA_TO_PROCESS;
  4312.                     }
  4313.                 }
  4314.  
  4315.                 break;
  4316.  
  4317.                 case DATATYPE_SCREENIMAGE:
  4318.                 {
  4319.                     if(!SaveWindow(FileName,Window))
  4320.                     {
  4321.                         Results[0] = RC_ERROR;
  4322.                         Results[1] = IoErr();
  4323.                     }
  4324.                 }
  4325.  
  4326.                 break;
  4327.             }
  4328.         }
  4329.         else
  4330.             Results[0] = RC_WARN;
  4331.     }
  4332.  
  4333.     return(NULL);
  4334. }
  4335.  
  4336. STRPTR
  4337. RexxSave(struct RexxPkt *Pkt)
  4338. {
  4339.     enum    {    ARG_SAVE_FROM };
  4340.  
  4341.     Args[1] = Args[ARG_SAVE_FROM];
  4342.     Args[0] = NULL;
  4343.  
  4344.     return(RexxSaveAs(Pkt));
  4345. }
  4346.  
  4347. STRPTR
  4348. RexxSelect(struct RexxPkt *Pkt)
  4349. {
  4350.     enum    {    ARG_SELECT_NAME,ARG_SELECT_FROM,ARG_SELECT_NEXT,ARG_SELECT_PREVIOUS,
  4351.             ARG_SELECT_TOP,ARG_SELECT_BOTTOM };
  4352.  
  4353.     WORD Index;
  4354.  
  4355.     if((Index = ToList(Args[ARG_SELECT_FROM])) == -1)
  4356.     {
  4357.         Results[0] = RC_ERROR;
  4358.         Results[1] = TERMERROR_UNKNOWN_LIST;
  4359.     }
  4360.     else
  4361.     {
  4362.         if(Args[ARG_SELECT_NAME] && Index == GLIST_DIAL)
  4363.         {
  4364.             Results[0] = RC_ERROR;
  4365.             Results[1] = TERMERROR_DATA_TYPES_INCOMPATIBLE;
  4366.         }
  4367.         else
  4368.         {
  4369.             struct GenericList *List;
  4370.  
  4371.             List = GenericListTable[Index];
  4372.  
  4373.             if(Args[ARG_SELECT_NAME])
  4374.             {
  4375.                 STRPTR Buffer;
  4376.  
  4377.                 if(Buffer = CreateMatchBuffer(Args[ARG_SELECT_NAME]))
  4378.                 {
  4379.                     struct Node *Node,*NextNode;
  4380.  
  4381.                     ObtainSemaphore(&List -> ListSemaphore);
  4382.  
  4383.                     Node = (struct Node *)List -> ListHeader . mlh_Head;
  4384.  
  4385.                     while(NextNode = Node -> ln_Succ)
  4386.                     {
  4387.                         if(MatchBuffer(Buffer,Node -> ln_Name))
  4388.                         {
  4389.                             List -> ListNode = Node;
  4390.  
  4391.                             Node = NULL;
  4392.  
  4393.                             break;
  4394.                         }
  4395.  
  4396.                         Node = NextNode;
  4397.                     }
  4398.  
  4399.                     if(Node)
  4400.                         Results[0] = RC_WARN;
  4401.  
  4402.                     ReleaseSemaphore(&List -> ListSemaphore);
  4403.  
  4404.                     DeleteMatchBuffer(Buffer);
  4405.                 }
  4406.                 else
  4407.                 {
  4408.                     Results[0] = RC_ERROR;
  4409.                     Results[1] = ERROR_NO_FREE_STORE;
  4410.                 }
  4411.             }
  4412.             else
  4413.             {
  4414.                 if(Args[ARG_SELECT_NEXT])
  4415.                 {
  4416.                     if(!NextGenericListNode(List))
  4417.                     {
  4418.                         Results[0] = RC_WARN;
  4419.  
  4420.                         return(NULL);
  4421.                     }
  4422.                 }
  4423.  
  4424.                 if(Args[ARG_SELECT_PREVIOUS])
  4425.                 {
  4426.                     if(!PrevGenericListNode(List))
  4427.                     {
  4428.                         Results[0] = RC_WARN;
  4429.  
  4430.                         return(NULL);
  4431.                     }
  4432.                 }
  4433.  
  4434.                 if(Args[ARG_SELECT_TOP])
  4435.                 {
  4436.                     if(!FirstGenericListNode(List))
  4437.                     {
  4438.                         Results[0] = RC_WARN;
  4439.  
  4440.                         return(NULL);
  4441.                     }
  4442.                 }
  4443.  
  4444.                 if(Args[ARG_SELECT_BOTTOM])
  4445.                 {
  4446.                     if(!LastGenericListNode(List))
  4447.                     {
  4448.                         Results[0] = RC_WARN;
  4449.  
  4450.                         return(NULL);
  4451.                     }
  4452.                 }
  4453.             }
  4454.  
  4455.             ObtainSemaphore(&List -> ListSemaphore);
  4456.  
  4457.             if(List -> ListNode)
  4458.             {
  4459.                 if(Index != GLIST_DIAL)
  4460.                 {
  4461.                     struct Node    *Node = (struct Node *)List -> ListNode;
  4462.                     STRPTR         Result;
  4463.  
  4464.                     Result = CreateResult(Node -> ln_Name,Results);
  4465.  
  4466.                     ReleaseSemaphore(&List -> ListSemaphore);
  4467.  
  4468.                     return(Result);
  4469.                 }
  4470.             }
  4471.             else
  4472.                 Results[0] = RC_WARN;
  4473.  
  4474.             ReleaseSemaphore(&List -> ListSemaphore);
  4475.         }
  4476.     }
  4477.  
  4478.     return(NULL);
  4479. }
  4480.  
  4481. STRPTR
  4482. RexxSend(struct RexxPkt *Pkt)
  4483. {
  4484.     enum    {    ARG_SEND_NOECHO,ARG_SEND_LOCAL,ARG_SEND_LITERAL,ARG_SEND_BYTE,ARG_SEND_TEXT };
  4485.  
  4486.     if(Args[ARG_SEND_LOCAL])
  4487.     {
  4488.         if(!Args[ARG_SEND_NOECHO])
  4489.         {
  4490.             if(Marking)
  4491.                 DropMarker();
  4492.  
  4493.             if(Args[ARG_SEND_TEXT])
  4494.             {
  4495.                 if(Args[ARG_SEND_LITERAL])
  4496.                     ConProcess(Args[ARG_SEND_TEXT],strlen(Args[ARG_SEND_TEXT]));
  4497.                 else
  4498.                     ConsoleCommand(Args[ARG_SEND_TEXT]);
  4499.             }
  4500.             else
  4501.             {
  4502.                 UBYTE Byte = *(LONG *)Args[ARG_SEND_BYTE];
  4503.  
  4504.                 ConProcess(&Byte,1);
  4505.             }
  4506.         }
  4507.     }
  4508.     else
  4509.     {
  4510.         if(Args[ARG_SEND_NOECHO])
  4511.             Quiet = TRUE;
  4512.  
  4513.         if(Args[ARG_SEND_TEXT])
  4514.         {
  4515.             if(Args[ARG_SEND_LITERAL])
  4516.                 SerWrite(Args[ARG_SEND_TEXT],strlen(Args[ARG_SEND_TEXT]));
  4517.             else
  4518.                 SerialCommand(Args[ARG_SEND_TEXT]);
  4519.         }
  4520.         else
  4521.         {
  4522.             UBYTE Byte = *(LONG *)Args[ARG_SEND_BYTE];
  4523.  
  4524.             SerWrite(&Byte,1);
  4525.         }
  4526.  
  4527.         Quiet = FALSE;
  4528.     }
  4529.  
  4530.     return(NULL);
  4531. }
  4532.  
  4533. STRPTR
  4534. RexxSendBreak(struct RexxPkt *Pkt)
  4535. {
  4536.     if(WriteRequest)
  4537.         SendBreak();
  4538.     else
  4539.         Results[0] = RC_WARN;
  4540.  
  4541.     return(NULL);
  4542. }
  4543.  
  4544. STRPTR
  4545. RexxSendFile(struct RexxPkt *Pkt)
  4546. {
  4547.     enum    {    ARG_SENDFILE_MODE,ARG_SENDFILE_NAMES };
  4548.  
  4549.     WORD Mode = TRANSFER_BINARY;
  4550.  
  4551.     if(Args[ARG_SENDFILE_MODE])
  4552.         Mode = ToMode(Args[ARG_SENDFILE_MODE]);
  4553.  
  4554.     if(Mode == -1)
  4555.     {
  4556.         Results[0] = RC_ERROR;
  4557.         Results[1] = ERROR_ACTION_NOT_KNOWN;
  4558.     }
  4559.     else
  4560.     {
  4561.         struct FileTransferInfo    *Info;
  4562.         LONG             FilesFound = 0;
  4563.         UBYTE             LocalBuffer[MAX_FILENAME_LENGTH];
  4564.  
  4565.         Results[0] = RC_OK;
  4566.  
  4567.         DB(kprintf("> allocfiletransferinfo\n"));
  4568.         if(Info = AllocFileTransferInfo())
  4569.         {
  4570.             struct GenericList *List = GenericListTable[GLIST_UPLOAD];
  4571.  
  4572.             if(Args[ARG_SENDFILE_NAMES])
  4573.             {
  4574.                 struct FileInfoBlock __aligned     FileInfo;
  4575.                 STRPTR                *Names = (STRPTR *)Args[ARG_SENDFILE_NAMES];
  4576.                 BPTR                 FileLock,NewDir,OldDir;
  4577.  
  4578.                 NewDir = NULL;
  4579.  
  4580.                 switch(Mode)
  4581.                 {
  4582.                     case TRANSFER_BINARY:
  4583.  
  4584.                         if(Config -> PathConfig -> BinaryUploadPath[0])
  4585.                             NewDir = Lock(Config -> PathConfig -> BinaryUploadPath,ACCESS_READ);
  4586.  
  4587.                         break;
  4588.  
  4589.                     case TRANSFER_TEXT:
  4590.  
  4591.                         if(Config -> PathConfig -> TextUploadPath[0])
  4592.                             NewDir = Lock(Config -> PathConfig -> TextUploadPath,ACCESS_READ);
  4593.  
  4594.                         break;
  4595.  
  4596.                     case TRANSFER_ASCII:
  4597.  
  4598.                         if(Config -> PathConfig -> ASCIIUploadPath[0])
  4599.                             NewDir = Lock(Config -> PathConfig -> ASCIIUploadPath,ACCESS_READ);
  4600.  
  4601.                         break;
  4602.                 }
  4603.  
  4604.                 if(NewDir)
  4605.                     OldDir = CurrentDir(NewDir);
  4606.  
  4607.                 while(*Names && Results[0] == RC_OK)
  4608.                 {
  4609.                     if(FileLock = Lock(*Names,ACCESS_READ))
  4610.                     {
  4611.                         if(Examine(FileLock,&FileInfo))
  4612.                         {
  4613.                             if(FileInfo . fib_DirEntryType < 0)
  4614.                             {
  4615.                                 if(NameFromLock(FileLock,LocalBuffer,MAX_FILENAME_LENGTH))
  4616.                                 {
  4617.                                     if(AddFileTransferNode(Info,LocalBuffer,FileInfo . fib_Size))
  4618.                                         FilesFound++;
  4619.                                     else
  4620.                                     {
  4621.                                         Results[0] = RC_ERROR;
  4622.                                         Results[1] = ERROR_NO_FREE_STORE;
  4623.                                     }
  4624.                                 }
  4625.                                 else
  4626.                                 {
  4627.                                     Results[0] = RC_ERROR;
  4628.                                     Results[1] = IoErr();
  4629.                                 }
  4630.                             }
  4631.                             else
  4632.                             {
  4633.                                 Results[0] = RC_ERROR;
  4634.                                 Results[1] = ERROR_OBJECT_WRONG_TYPE;
  4635.                             }
  4636.                         }
  4637.                         else
  4638.                         {
  4639.                             Results[0] = RC_ERROR;
  4640.                             Results[1] = IoErr();
  4641.                         }
  4642.  
  4643.                         UnLock(FileLock);
  4644.                     }
  4645.                     else
  4646.                     {
  4647.                         Results[0] = RC_ERROR;
  4648.                         Results[1] = IoErr();
  4649.                     }
  4650.  
  4651.                     Names++;
  4652.                 }
  4653.  
  4654.                 if(NewDir)
  4655.                 {
  4656.                     CurrentDir(OldDir);
  4657.                     UnLock(NewDir);
  4658.                 }
  4659.             }
  4660.  
  4661.             ObtainSemaphore(&List -> ListSemaphore);
  4662.  
  4663.             DB(kprintf("> building list\n"));
  4664.             if(List -> ListHeader . mlh_Head -> mln_Succ && Results[0] == RC_OK)
  4665.             {
  4666.                 struct FileInfoBlock __aligned     FileInfo;
  4667.                 struct Node            *Node;
  4668.                 BPTR                 NewDir,OldDir;
  4669.                 BPTR                 FileLock;
  4670.  
  4671.                 NewDir = NULL;
  4672.  
  4673.                 switch(Mode)
  4674.                 {
  4675.                     case TRANSFER_BINARY:
  4676.  
  4677.                         if(Config -> PathConfig -> BinaryUploadPath[0])
  4678.                             NewDir = Lock(Config -> PathConfig -> BinaryUploadPath,ACCESS_READ);
  4679.  
  4680.                         break;
  4681.  
  4682.                     case TRANSFER_TEXT:
  4683.  
  4684.                         if(Config -> PathConfig -> TextUploadPath[0])
  4685.                             NewDir = Lock(Config -> PathConfig -> TextUploadPath,ACCESS_READ);
  4686.  
  4687.                         break;
  4688.  
  4689.                     case TRANSFER_ASCII:
  4690.  
  4691.                         if(Config -> PathConfig -> ASCIIUploadPath[0])
  4692.                             NewDir = Lock(Config -> PathConfig -> ASCIIUploadPath,ACCESS_READ);
  4693.  
  4694.                         break;
  4695.                 }
  4696.  
  4697.                 DB(kprintf("> changedir\n"));
  4698.                 if(NewDir)
  4699.                     OldDir = CurrentDir(NewDir);
  4700.  
  4701.                 for(Node = (struct Node *)List -> ListHeader . mlh_Head ; Node -> ln_Succ && Results[0] == RC_OK ; Node = Node -> ln_Succ)
  4702.                 {
  4703.                     if(FileLock = Lock(Node -> ln_Name,ACCESS_READ))
  4704.                     {
  4705.                         if(Examine(FileLock,&FileInfo))
  4706.                         {
  4707.                             if(FileInfo . fib_DirEntryType < 0)
  4708.                             {
  4709.                                 if(NameFromLock(FileLock,LocalBuffer,MAX_FILENAME_LENGTH))
  4710.                                 {
  4711.                                     DB(kprintf("> adding |%s|\n",LocalBuffer));
  4712.                                     if(AddFileTransferNode(Info,LocalBuffer,FileInfo . fib_Size))
  4713.                                         FilesFound++;
  4714.                                     else
  4715.                                     {
  4716.                                         Results[0] = RC_ERROR;
  4717.                                         Results[1] = ERROR_NO_FREE_STORE;
  4718.                                     }
  4719.                                 }
  4720.                                 else
  4721.                                 {
  4722.                                     Results[0] = RC_ERROR;
  4723.                                     Results[1] = IoErr();
  4724.                                 }
  4725.                             }
  4726.                             else
  4727.                             {
  4728.                                 Results[0] = RC_ERROR;
  4729.                                 Results[1] = ERROR_OBJECT_WRONG_TYPE;
  4730.                             }
  4731.                         }
  4732.                         else
  4733.                         {
  4734.                             Results[0] = RC_ERROR;
  4735.                             Results[1] = IoErr();
  4736.                         }
  4737.  
  4738.                         UnLock(FileLock);
  4739.                     }
  4740.                     else
  4741.                     {
  4742.                         Results[0] = RC_ERROR;
  4743.                         Results[1] = IoErr();
  4744.                     }
  4745.                 }
  4746.  
  4747.                 DB(kprintf("> move back\n"));
  4748.                 if(NewDir)
  4749.                 {
  4750.                     CurrentDir(OldDir);
  4751.                     UnLock(NewDir);
  4752.                 }
  4753.             }
  4754.  
  4755.             ReleaseSemaphore(&List -> ListSemaphore);
  4756.  
  4757.             if(Results[0] == RC_OK)
  4758.             {
  4759.                 BlockWindows();
  4760.  
  4761.                 if(FilesFound)
  4762.                 {
  4763.                     DB(kprintf("> sorting\n"));
  4764.                     SortFileTransferInfo(Info);
  4765.  
  4766.                     FileTransferInfo = Info;
  4767.                 }
  4768.  
  4769.                 switch(Mode)
  4770.                 {
  4771.                     case TRANSFER_ASCII:
  4772.  
  4773.                         if(ChangeProtocol(Config -> TransferConfig -> ASCIIUploadLibrary,Config -> TransferConfig -> ASCIIUploadType))
  4774.                         {
  4775.                             BinaryTransfer = FALSE;
  4776.  
  4777.                             if(FilesFound)
  4778.                                 StartXprSendFromList(TRANSFER_ASCII,FALSE);
  4779.                             else
  4780.                                 StartXprSend(TRANSFER_ASCII,FALSE);
  4781.  
  4782.                             BinaryTransfer = TRUE;
  4783.                         }
  4784.                         else
  4785.                         {
  4786.                             Results[0] = RC_ERROR;
  4787.                             Results[1] = ERROR_NO_FREE_STORE;
  4788.                         }
  4789.  
  4790.                         ResetProtocol();
  4791.  
  4792.                         break;
  4793.  
  4794.                     case TRANSFER_TEXT:
  4795.  
  4796.                         if(ChangeProtocol(Config -> TransferConfig -> TextUploadLibrary,Config -> TransferConfig -> TextUploadType))
  4797.                         {
  4798.                             BinaryTransfer = FALSE;
  4799.  
  4800.                             if(FilesFound)
  4801.                                 StartXprSendFromList(TRANSFER_TEXT,FALSE);
  4802.                             else
  4803.                                 StartXprSend(TRANSFER_TEXT,FALSE);
  4804.  
  4805.                             BinaryTransfer = TRUE;
  4806.                         }
  4807.                         else
  4808.                         {
  4809.                             Results[0] = RC_ERROR;
  4810.                             Results[1] = ERROR_NO_FREE_STORE;
  4811.                         }
  4812.  
  4813.                         ResetProtocol();
  4814.  
  4815.                         break;
  4816.  
  4817.                     case TRANSFER_BINARY:
  4818.  
  4819.                         if(ChangeProtocol(Config -> TransferConfig -> BinaryUploadLibrary,Config -> TransferConfig -> BinaryUploadType))
  4820.                         {
  4821.                             BinaryTransfer = TRUE;
  4822.  
  4823.                             DB(kprintf("> starting\n"));
  4824.                             if(FilesFound)
  4825.                                 StartXprSendFromList(TRANSFER_BINARY,FALSE);
  4826.                             else
  4827.                                 StartXprSend(TRANSFER_BINARY,FALSE);
  4828.                         }
  4829.                         else
  4830.                         {
  4831.                             Results[0] = RC_ERROR;
  4832.                             Results[1] = ERROR_NO_FREE_STORE;
  4833.                         }
  4834.  
  4835.                         ResetProtocol();
  4836.  
  4837.                         break;
  4838.                 }
  4839.  
  4840.                 DB(kprintf("> thats it\n"));
  4841.                 if(TransferFailed)
  4842.                     Results[0] = RC_ERROR;
  4843.  
  4844.                 if(TransferAborted)
  4845.                     Results[0] = RC_WARN;
  4846.  
  4847.                 ReleaseWindows();
  4848.             }
  4849.             else
  4850.                 FreeFileTransferInfo(Info);
  4851.         }
  4852.         else
  4853.         {
  4854.             Results[0] = RC_ERROR;
  4855.             Results[1] = ERROR_NO_FREE_STORE;
  4856.         }
  4857.     }
  4858.  
  4859.     return(NULL);
  4860. }
  4861.  
  4862. STRPTR
  4863. RexxSpeak(struct RexxPkt *Pkt)
  4864. {
  4865.     enum    {    ARG_SPEAK_TEXT };
  4866.  
  4867.     if(SpeechConfig . Enabled && English)
  4868.         Say(Args[ARG_SPEAK_TEXT]);
  4869.     else
  4870.         Results[0] = RC_WARN;
  4871.  
  4872.     return(NULL);
  4873. }
  4874.  
  4875. STRPTR
  4876. RexxStopBits(struct RexxPkt *Pkt)
  4877. {
  4878.     enum    {    ARG_STOPBITS_0,ARG_STOPBITS_1 };
  4879.  
  4880.     BYTE Bits;
  4881.  
  4882.     if(Args[ARG_STOPBITS_0])
  4883.         Bits = 0;
  4884.  
  4885.     if(Args[ARG_STOPBITS_1])
  4886.         Bits = 1;
  4887.  
  4888.     if(Config -> SerialConfig -> StopBits != Bits)
  4889.     {
  4890.         Config -> SerialConfig -> StopBits = Bits;
  4891.  
  4892.         UpdateRequired = TRUE;
  4893.  
  4894.         ConfigChanged = TRUE;
  4895.     }
  4896.  
  4897.     return(NULL);
  4898. }
  4899.  
  4900. STRPTR
  4901. RexxTextBuffer(struct RexxPkt *Pkt)
  4902. {
  4903.     enum    {    ARG_TEXTBUFFER_LOCK,ARG_TEXTBUFFER_UNLOCK };
  4904.  
  4905.     Forbid();
  4906.  
  4907.     if(Args[ARG_TEXTBUFFER_LOCK])
  4908.         BufferFrozen = TRUE;
  4909.  
  4910.     if(Args[ARG_TEXTBUFFER_UNLOCK])
  4911.         BufferFrozen = FALSE;
  4912.  
  4913.     CheckItem(MEN_FREEZE_BUFFER,BufferFrozen);
  4914.  
  4915.     ConOutputUpdate();
  4916.  
  4917.     Permit();
  4918.  
  4919.     return(NULL);
  4920. }
  4921.  
  4922. STRPTR
  4923. RexxTimeout(struct RexxPkt *Pkt)
  4924. {
  4925.     enum    {    ARG_TIMEOUT_SECONDS,ARG_TIMEOUT_OFF };
  4926.  
  4927.     if(Args[ARG_TIMEOUT_OFF])
  4928.         RexxTimeoutVal = 0;
  4929.     else
  4930.         RexxTimeoutVal = *(LONG *)Args[ARG_TIMEOUT_SECONDS];
  4931.  
  4932.     return(NULL);
  4933.  
  4934. }
  4935.  
  4936. STRPTR
  4937. RexxTrap(struct RexxPkt *Pkt)
  4938. {
  4939.     enum    {    ARG_TRAP_ON,ARG_TRAP_OFF };
  4940.  
  4941.     BOOLEAN Enabled;
  4942.  
  4943.     Forbid();
  4944.  
  4945.     if(Args[ARG_TRAP_ON])
  4946.         Enabled = TRUE;
  4947.  
  4948.     if(Args[ARG_TRAP_OFF])
  4949.         Enabled = FALSE;
  4950.  
  4951.     CheckItem(MEN_DISABLE_TRAPS,Enabled ^ TRUE);
  4952.  
  4953.     Permit();
  4954.  
  4955.     ObtainSemaphore(&GenericListTable[GLIST_TRAP] -> ListSemaphore);
  4956.  
  4957.     if(GenericListTable[GLIST_TRAP] -> ListHeader . mlh_Head -> mln_Succ && Enabled)
  4958.         WatchTraps = TRUE;
  4959.     else
  4960.         WatchTraps = FALSE;
  4961.  
  4962.     ReleaseSemaphore(&GenericListTable[GLIST_TRAP] -> ListSemaphore);
  4963.  
  4964.     return(NULL);
  4965. }
  4966.  
  4967. STATIC STRPTR         RexxWaitResult;
  4968. STATIC struct WaitNode    *RexxWaitNode;
  4969.  
  4970. STATIC BOOLEAN
  4971. RexxWaitBypass(STRPTR Buffer,LONG Size)
  4972. {
  4973.     LONG Position;
  4974.  
  4975.     RexxWaitResult = ScanNodeFilter(Buffer,Size,RexxWaitNode,&Position);
  4976.  
  4977.     SerWriteVerbatim(Buffer,Size,FALSE);
  4978.  
  4979.     return(FALSE);
  4980. }
  4981.  
  4982. STRPTR
  4983. RexxWait(struct RexxPkt *Pkt)
  4984. {
  4985.     enum    {    ARG_WAIT_NOECHO,ARG_WAIT_TEXT };
  4986.  
  4987.     ULONG         Signals;
  4988.     STRPTR         Result = NULL;
  4989.     BYTE         Echo;
  4990.     struct WaitNode    *WaitNode,
  4991.              Node;
  4992.     UBYTE         DummyBuffer[MAX_FILENAME_LENGTH];
  4993.     LONG         Position;
  4994.     struct List     DummyList;
  4995.  
  4996.     if(!ReadRequest || !WriteRequest)
  4997.     {
  4998.         Results[0] = RC_WARN;
  4999.  
  5000.         return(NULL);
  5001.     }
  5002.  
  5003.     if(Args[ARG_WAIT_NOECHO])
  5004.         Echo = FALSE;
  5005.     else
  5006.         Echo = TRUE;
  5007.  
  5008.     if(Args[ARG_WAIT_TEXT])
  5009.     {
  5010.         WORD i,Len;
  5011.  
  5012.         NewList(&DummyList);
  5013.  
  5014.         memcpy(DummyBuffer,Args[ARG_WAIT_TEXT],255);
  5015.  
  5016.         DummyBuffer[255] = 0;
  5017.  
  5018.         for(i = 0 ; i < strlen(DummyBuffer) ; i++)
  5019.             DummyBuffer[i] = ToUpper(DummyBuffer[i]);
  5020.  
  5021.         Len = TranslateString(DummyBuffer,DummyBuffer);
  5022.  
  5023.         DummyBuffer[Len] = 0;
  5024.  
  5025.         memset(&Node,0,sizeof(struct WaitNode));
  5026.  
  5027.         Node . Node . ln_Name    = DummyBuffer;
  5028.         Node . Count        = 0;
  5029.  
  5030.         WaitNode = &Node;
  5031.  
  5032.         AddTail(&DummyList,(struct Node *)WaitNode);
  5033.     }
  5034.     else
  5035.     {
  5036.         if(!GenericListCount(GenericListTable[GLIST_WAIT]))
  5037.         {
  5038.             Results[0] = RC_ERROR;
  5039.             Results[1] = TERMERROR_LIST_IS_ALREADY_EMPTY;
  5040.  
  5041.             return(NULL);
  5042.         }
  5043.         else
  5044.         {
  5045.             WaitNode = (struct WaitNode *)GenericListTable[GLIST_WAIT] -> ListHeader . mlh_Head;
  5046.  
  5047.             while(WaitNode -> Node . ln_Succ)
  5048.             {
  5049.                 WaitNode -> Count = 0;
  5050.  
  5051.                 WaitNode = (struct WaitNode *)WaitNode -> Node . ln_Succ;
  5052.             }
  5053.  
  5054.             WaitNode = NULL;
  5055.         }
  5056.     }
  5057.  
  5058.     if(RexxTimeoutVal)
  5059.         StartTime(RexxTimeoutVal,0);
  5060.  
  5061.     WaitCount = 0;
  5062.  
  5063.     BlockWindows();
  5064.  
  5065.     Forbid();
  5066.  
  5067.     LT_UnlockWindow(Window);
  5068.  
  5069.     Window -> Flags |= WFLG_RMBTRAP;
  5070.  
  5071.     Permit();
  5072.  
  5073.     if(Marking)
  5074.         DropMarker();
  5075.  
  5076.     NormalCursor();
  5077.  
  5078.     if(DataHold)
  5079.     {
  5080.         if(Echo)
  5081.         {
  5082.             ConProcess(DataHold,DataSize);
  5083.  
  5084.             Status = STATUS_READY;
  5085.         }
  5086.  
  5087.         if(Result = ScanNodeFilter(DataHold,DataSize,WaitNode,&Position))
  5088.         {
  5089.             if(Position < DataSize)
  5090.             {
  5091.                 DataHold += Position;
  5092.                 DataSize -= Position;
  5093.             }
  5094.             else
  5095.             {
  5096.                 DataHold = NULL;
  5097.  
  5098.                 RestartSerial();
  5099.             }
  5100.         }
  5101.         else
  5102.         {
  5103.             DataHold = NULL;
  5104.  
  5105.             RestartSerial();
  5106.         }
  5107.     }
  5108.  
  5109.     if(!Result)
  5110.     {
  5111.         if(CheckSerialRead())
  5112.             Signals = SIG_SERIAL;
  5113.         else
  5114.             Signals = NULL;
  5115.  
  5116.         do
  5117.         {
  5118.             if(Signals & SIG_WINDOW)
  5119.             {
  5120.                 if(!Result)
  5121.                 {
  5122.                     SerWriteBypass = RexxWaitBypass;
  5123.  
  5124.                     RexxWaitResult    = Result;
  5125.                     RexxWaitNode    = WaitNode;
  5126.  
  5127.                     while(HandleWindow());
  5128.  
  5129.                     Result = RexxWaitResult;
  5130.  
  5131.                     SerWriteBypass = NULL;
  5132.                 }
  5133.             }
  5134.  
  5135.             if(Signals & SIG_SERIAL)
  5136.             {
  5137.                 BOOLEAN Restart = TRUE;
  5138.  
  5139.                 if(!WaitSerialRead())
  5140.                 {
  5141.                     LONG Length;
  5142.  
  5143.                     BytesIn++;
  5144.  
  5145.                     if(Translate_CR_LF)
  5146.                         Length = (*Translate_CR_LF)(ReadBuffer,1);
  5147.                     else
  5148.                         Length = 1;
  5149.  
  5150.                     if(Echo && Length)
  5151.                     {
  5152.                         ConProcess(ReadBuffer,Length);
  5153.  
  5154.                         Status = STATUS_READY;
  5155.                     }
  5156.  
  5157.                     if(!Result && Length)
  5158.                         Result = ScanNodeFilter(ReadBuffer,Length,WaitNode,&Position);
  5159.  
  5160.                     if(!Result)
  5161.                     {
  5162.                             /* Check how many bytes are still in
  5163.                              * the serial buffer.
  5164.                              */
  5165.  
  5166.                         if(Length = GetSerialWaiting())
  5167.                         {
  5168.                             if(Length > SerialBufferSize)
  5169.                                 Length = SerialBufferSize;
  5170.  
  5171.                             if(Length > Config -> SerialConfig -> Quantum)
  5172.                                 Length = Config -> SerialConfig -> Quantum;
  5173.  
  5174.                             if(!DoSerialRead(ReadBuffer,Length))
  5175.                             {
  5176.                                 BytesIn += Length;
  5177.  
  5178.                                 if(Translate_CR_LF)
  5179.                                     Length = (* Translate_CR_LF)(ReadBuffer,Length);
  5180.  
  5181.                                 if(Length)
  5182.                                 {
  5183.                                         /* Send the data to the console. */
  5184.  
  5185.                                     if(Echo)
  5186.                                     {
  5187.                                         ConProcess(ReadBuffer,Length);
  5188.  
  5189.                                         Status = STATUS_READY;
  5190.                                     }
  5191.  
  5192.                                     if(Result = ScanNodeFilter(ReadBuffer,Length,WaitNode,&Position))
  5193.                                     {
  5194.                                         if(Position < Length)
  5195.                                         {
  5196.                                             DataHold = (UBYTE *)ReadBuffer    + Position;
  5197.                                             DataSize = Length        - Position;
  5198.  
  5199.                                             Restart = FALSE;
  5200.                                         }
  5201.                                         else
  5202.                                             DataHold = NULL;
  5203.                                     }
  5204.                                 }
  5205.                             }
  5206.                         }
  5207.                     }
  5208.                 }
  5209.  
  5210.                 if(Restart)
  5211.                     RestartSerial();
  5212.             }
  5213.  
  5214.             if(Signals & (SIG_BREAK | SIG_TIMER))
  5215.             {
  5216.                 if(!Result)
  5217.                     Results[0] = RC_WARN;
  5218.  
  5219.                 break;
  5220.             }
  5221.  
  5222.             if(!Result)
  5223.                 Signals = Wait(SIG_SERIAL | SIG_TIMER | SIG_BREAK | SIG_WINDOW);
  5224.         }
  5225.         while(!Result);
  5226.     }
  5227.  
  5228.     Forbid();
  5229.  
  5230.     Window -> Flags &= ~WFLG_RMBTRAP;
  5231.  
  5232.     LT_LockWindow(Window);
  5233.  
  5234.     Permit();
  5235.  
  5236.     ReleaseWindows();
  5237.  
  5238.     if(RexxTimeoutVal)
  5239.         StopTime();
  5240.  
  5241.     if(Result)
  5242.         return(CreateResult(Result,Results));
  5243.     else
  5244.         return(NULL);
  5245. }
  5246.  
  5247. STRPTR
  5248. RexxWindow(struct RexxPkt *Pkt)
  5249. {
  5250.     enum    {    ARG_WINDOW_NAMES,ARG_WINDOW_OPEN,ARG_WINDOW_CLOSE,ARG_WINDOW_ACTIVATE,
  5251.             ARG_WINDOW_MIN,ARG_WINDOW_MAX,ARG_WINDOW_FRONT,ARG_WINDOW_BACK,
  5252.             ARG_WINDOW_TOP,ARG_WINDOW_BOTTOM,ARG_WINDOW_UP,ARG_WINDOW_DOWN };
  5253.  
  5254.     STRPTR    *Names = (STRPTR *)Args[ARG_WINDOW_NAMES];
  5255.     WORD     Index;
  5256.  
  5257.     while(*Names)
  5258.     {
  5259.         if((Index = ToWindow(*Names++)) != -1)
  5260.         {
  5261.             if(Args[ARG_WINDOW_OPEN])
  5262.             {
  5263.                 Forbid();
  5264.  
  5265.                 switch(Index)
  5266.                 {
  5267.                     case WINDOWID_BUFFER:
  5268.  
  5269.                         LaunchBuffer();
  5270.                         break;
  5271.  
  5272.                     case WINDOWID_UPLOAD_QUEUE:
  5273.  
  5274.                         CreateQueueProcess();
  5275.  
  5276.                         break;
  5277.  
  5278.                     case WINDOWID_REVIEW:
  5279.  
  5280.                         if(!ReviewWindow)
  5281.                             CreateReview();
  5282.  
  5283.                         break;
  5284.  
  5285.                     case WINDOWID_PACKET:
  5286.  
  5287.                         if(!PacketWindow)
  5288.                             CreatePacketWindow();
  5289.  
  5290.                         break;
  5291.  
  5292.                     case WINDOWID_FASTMACROS:
  5293.  
  5294.                         if(!FastWindow)
  5295.                             OpenFastWindow();
  5296.  
  5297.                         break;
  5298.  
  5299.                     case WINDOWID_STATUS:
  5300.  
  5301.                         if(!InfoWindow)
  5302.                             OpenInfoWindow();
  5303.  
  5304.                         break;
  5305.  
  5306.                     case WINDOWID_MAIN:
  5307.  
  5308.                         if(!IconTerminated)
  5309.                             IconTerminated = TRUE;
  5310.  
  5311.                         break;
  5312.  
  5313.                     case WINDOWID_SINGLE_CHAR_ENTRY:
  5314.  
  5315.                         if(Window)
  5316.                             OpenMatrixWindow(Window);
  5317.  
  5318.                         break;
  5319.                 }
  5320.  
  5321.                 Permit();
  5322.             }
  5323.  
  5324.             if(Args[ARG_WINDOW_CLOSE])
  5325.             {
  5326.                 Forbid();
  5327.  
  5328.                 switch(Index)
  5329.                 {
  5330.                     case WINDOWID_UPLOAD_QUEUE:
  5331.  
  5332.                         CloseQueueWindow();
  5333.                         break;
  5334.  
  5335.                     case WINDOWID_BUFFER:
  5336.  
  5337.                         TerminateBuffer();
  5338.                         break;
  5339.  
  5340.                     case WINDOWID_REVIEW:
  5341.  
  5342.                         if(ReviewWindow)
  5343.                             DeleteReview();
  5344.  
  5345.                         break;
  5346.  
  5347.                     case WINDOWID_PACKET:
  5348.  
  5349.                         if(PacketWindow)
  5350.                             DeletePacketWindow(FALSE);
  5351.  
  5352.                         break;
  5353.  
  5354.                     case WINDOWID_FASTMACROS:
  5355.  
  5356.                         if(FastWindow)
  5357.                             CloseFastWindow();
  5358.  
  5359.                         break;
  5360.  
  5361.                     case WINDOWID_STATUS:
  5362.  
  5363.                         if(InfoWindow)
  5364.                             CloseInfoWindow();
  5365.  
  5366.                         break;
  5367.  
  5368.                     case WINDOWID_MAIN:
  5369.  
  5370.                         if(Window)
  5371.                             DoIconify = TRUE;
  5372.  
  5373.                         break;
  5374.  
  5375.                     case WINDOWID_SINGLE_CHAR_ENTRY:
  5376.  
  5377.                         CloseMatrixWindow();
  5378.                         break;
  5379.                 }
  5380.  
  5381.                 Permit();
  5382.             }
  5383.  
  5384.             if(Args[ARG_WINDOW_ACTIVATE])
  5385.             {
  5386.                 Forbid();
  5387.  
  5388.                 switch(Index)
  5389.                 {
  5390.                     case WINDOWID_UPLOAD_QUEUE:
  5391.  
  5392.                         CreateQueueProcess();
  5393.  
  5394.                         break;
  5395.  
  5396.                     case WINDOWID_BUFFER:
  5397.  
  5398.                         LaunchBuffer();
  5399.                         break;
  5400.  
  5401.                     case WINDOWID_REVIEW:
  5402.  
  5403.                         if(ReviewWindow)
  5404.                             BumpWindow(ReviewWindow);
  5405.  
  5406.                         break;
  5407.  
  5408.                     case WINDOWID_PACKET:
  5409.  
  5410.                         if(PacketWindow)
  5411.                             BumpWindow(PacketWindow);
  5412.  
  5413.                         break;
  5414.  
  5415.                     case WINDOWID_FASTMACROS:
  5416.  
  5417.                         if(FastWindow)
  5418.                             BumpWindow(FastWindow);
  5419.  
  5420.                         break;
  5421.  
  5422.                     case WINDOWID_STATUS:
  5423.  
  5424.                         if(InfoWindow)
  5425.                             BumpWindow(InfoWindow);
  5426.  
  5427.                         break;
  5428.  
  5429.                     case WINDOWID_MAIN:
  5430.  
  5431.                         if(Window)
  5432.                             BumpWindow(Window);
  5433.  
  5434.                         break;
  5435.  
  5436.                     case WINDOWID_SINGLE_CHAR_ENTRY:
  5437.  
  5438.                         if(MatrixWindow)
  5439.                             BumpWindow(MatrixWindow);
  5440.  
  5441.                         break;
  5442.                 }
  5443.  
  5444.                 Permit();
  5445.             }
  5446.  
  5447.             if(Args[ARG_WINDOW_MIN])
  5448.             {
  5449.                 struct Window *SomeWindow = NULL;
  5450.  
  5451.                 Forbid();
  5452.  
  5453.                 switch(Index)
  5454.                 {
  5455.                     case WINDOWID_REVIEW:
  5456.  
  5457.                         SomeWindow = ReviewWindow;
  5458.                         break;
  5459.  
  5460.                     case WINDOWID_PACKET:
  5461.  
  5462.                         SomeWindow = PacketWindow;
  5463.                         break;
  5464.  
  5465.                     case WINDOWID_FASTMACROS:
  5466.  
  5467.                         SomeWindow = FastWindow;
  5468.                         break;
  5469.  
  5470.                     case WINDOWID_STATUS:
  5471.  
  5472.                         SomeWindow = InfoWindow;
  5473.                         break;
  5474.                 }
  5475.  
  5476.                 if(SomeWindow)
  5477.                     ChangeWindowBox(SomeWindow,SomeWindow -> LeftEdge,SomeWindow -> TopEdge,SomeWindow -> MinWidth,SomeWindow -> MinHeight);
  5478.  
  5479.                 Permit();
  5480.             }
  5481.  
  5482.             if(Args[ARG_WINDOW_MAX])
  5483.             {
  5484.                 struct Window *SomeWindow = NULL;
  5485.  
  5486.                 Forbid();
  5487.  
  5488.                 switch(Index)
  5489.                 {
  5490.                     case WINDOWID_REVIEW:
  5491.  
  5492.                         SomeWindow = ReviewWindow;
  5493.                         break;
  5494.  
  5495.                     case WINDOWID_PACKET:
  5496.  
  5497.                         SomeWindow = PacketWindow;
  5498.                         break;
  5499.  
  5500.                     case WINDOWID_FASTMACROS:
  5501.  
  5502.                         SomeWindow = FastWindow;
  5503.                         break;
  5504.  
  5505.                     case WINDOWID_STATUS:
  5506.  
  5507.                         SomeWindow = InfoWindow;
  5508.                         break;
  5509.                 }
  5510.  
  5511.                 if(SomeWindow)
  5512.                     ChangeWindowBox(SomeWindow,0,0,SomeWindow -> MaxWidth,SomeWindow -> MaxHeight);
  5513.  
  5514.                 Permit();
  5515.             }
  5516.  
  5517.             if(Args[ARG_WINDOW_FRONT])
  5518.             {
  5519.                 Forbid();
  5520.  
  5521.                 switch(Index)
  5522.                 {
  5523.                     case WINDOWID_UPLOAD_QUEUE:
  5524.  
  5525.                         CreateQueueProcess();
  5526.  
  5527.                         break;
  5528.  
  5529.                     case WINDOWID_BUFFER:
  5530.  
  5531.                         LaunchBuffer();
  5532.                         break;
  5533.  
  5534.                     case WINDOWID_REVIEW:
  5535.  
  5536.                         if(ReviewWindow)
  5537.                             WindowToFront(ReviewWindow);
  5538.  
  5539.                         break;
  5540.  
  5541.                     case WINDOWID_PACKET:
  5542.  
  5543.                         if(PacketWindow)
  5544.                             WindowToFront(PacketWindow);
  5545.  
  5546.                         break;
  5547.  
  5548.                     case WINDOWID_FASTMACROS:
  5549.  
  5550.                         if(FastWindow)
  5551.                             WindowToFront(FastWindow);
  5552.  
  5553.                         break;
  5554.  
  5555.                     case WINDOWID_STATUS:
  5556.  
  5557.                         if(InfoWindow)
  5558.                             WindowToFront(InfoWindow);
  5559.  
  5560.                         break;
  5561.  
  5562.                     case WINDOWID_MAIN:
  5563.  
  5564.                         if(Window)
  5565.                             WindowToFront(Window);
  5566.  
  5567.                         break;
  5568.  
  5569.                     case WINDOWID_SINGLE_CHAR_ENTRY:
  5570.  
  5571.                         if(MatrixWindow)
  5572.                             WindowToFront(MatrixWindow);
  5573.  
  5574.                         break;
  5575.                 }
  5576.  
  5577.                 Permit();
  5578.             }
  5579.  
  5580.             if(Args[ARG_WINDOW_BACK])
  5581.             {
  5582.                 Forbid();
  5583.  
  5584.                 switch(Index)
  5585.                 {
  5586.                     case WINDOWID_REVIEW:
  5587.  
  5588.                         if(ReviewWindow)
  5589.                             WindowToBack(ReviewWindow);
  5590.  
  5591.                         break;
  5592.  
  5593.                     case WINDOWID_PACKET:
  5594.  
  5595.                         if(PacketWindow)
  5596.                             WindowToBack(PacketWindow);
  5597.  
  5598.                         break;
  5599.  
  5600.                     case WINDOWID_FASTMACROS:
  5601.  
  5602.                         if(FastWindow)
  5603.                             WindowToBack(FastWindow);
  5604.  
  5605.                         break;
  5606.  
  5607.                     case WINDOWID_STATUS:
  5608.  
  5609.                         if(InfoWindow)
  5610.                             WindowToBack(InfoWindow);
  5611.  
  5612.                         break;
  5613.  
  5614.                     case WINDOWID_MAIN:
  5615.  
  5616.                         if(Window)
  5617.                             WindowToBack(Window);
  5618.  
  5619.                         break;
  5620.  
  5621.                     case WINDOWID_SINGLE_CHAR_ENTRY:
  5622.  
  5623.                         if(MatrixWindow)
  5624.                             WindowToBack(MatrixWindow);
  5625.  
  5626.                         break;
  5627.                 }
  5628.  
  5629.                 Permit();
  5630.             }
  5631.  
  5632.             Forbid();
  5633.  
  5634.             if(Index == WINDOW_REVIEW && ReviewWindow)
  5635.             {
  5636.                 if(Args[ARG_WINDOW_TOP])
  5637.                     MoveReview(REVIEW_MOVE_TOP);
  5638.  
  5639.                 if(Args[ARG_WINDOW_BOTTOM])
  5640.                     MoveReview(REVIEW_MOVE_BOTTOM);
  5641.  
  5642.                 if(Args[ARG_WINDOW_UP])
  5643.                     MoveReview(REVIEW_MOVE_UP);
  5644.  
  5645.                 if(Args[ARG_WINDOW_DOWN])
  5646.                     MoveReview(REVIEW_MOVE_DOWN);
  5647.             }
  5648.  
  5649.             Permit();
  5650.         }
  5651.     }
  5652.  
  5653.     return(NULL);
  5654. }
  5655.  
  5656. STRPTR
  5657. RexxRX(struct RexxPkt *Pkt)
  5658. {
  5659.     enum    {    ARG_RX_CONSOLE,ARG_RX_ASYNC,ARG_RX_COMMAND };
  5660.  
  5661.     struct MsgPort    *RexxPort;
  5662.     BYTE         Eaten = FALSE;
  5663.  
  5664.     if(RexxPort = FindPort(RXSDIR))
  5665.     {
  5666.         struct MsgPort __aligned     SinglePort;
  5667.         struct RexxMsg            *HostMessage;
  5668.  
  5669.         InitSinglePort(&SinglePort);
  5670.  
  5671.         if(HostMessage = CreateRexxMsg(&SinglePort,"term",RexxPortName))
  5672.         {
  5673.             if(HostMessage -> rm_Args[0] = CreateArgstring(Args[ARG_RX_COMMAND],strlen(Args[ARG_RX_COMMAND])))
  5674.             {
  5675.                 HostMessage -> rm_Action = RXCOMM;
  5676.  
  5677.                 if(!GoodStream(NULL))
  5678.                     HostMessage -> rm_Action |= RXFF_NOIO;
  5679.  
  5680.                 if(Args[ARG_RX_ASYNC])
  5681.                 {
  5682.                     RexxPktCleanup(Pkt,NULL);
  5683.  
  5684.                     Eaten = TRUE;
  5685.                 }
  5686.  
  5687.                 Forbid();
  5688.  
  5689.                 PutMsg(RexxPort,HostMessage);
  5690.  
  5691.                 ClrSignal(SIGF_SINGLE);
  5692.  
  5693.                 WaitPort(&SinglePort);
  5694.  
  5695.                 Permit();
  5696.  
  5697.                 GetMsg(&SinglePort);
  5698.  
  5699.                 if(!Eaten)
  5700.                 {
  5701.                     Results[0] = HostMessage -> rm_Result1;
  5702.                     Results[1] = HostMessage -> rm_Result2;
  5703.                 }
  5704.             }
  5705.             else
  5706.             {
  5707.                 Results[0] = RC_ERROR;
  5708.                 Results[1] = ERR10_003;
  5709.             }
  5710.  
  5711.             DeleteRexxMsg(HostMessage);
  5712.         }
  5713.         else
  5714.         {
  5715.             Results[0] = RC_ERROR;
  5716.             Results[1] = ERR10_003;
  5717.         }
  5718.     }
  5719.     else
  5720.     {
  5721.         Results[0] = RC_ERROR;
  5722.         Results[1] = ERR10_013;
  5723.     }
  5724.  
  5725.     if(!Eaten)
  5726.         RexxPktCleanup(Pkt,NULL);
  5727.  
  5728.     return(NULL);
  5729. }
  5730.  
  5731. STRPTR
  5732. RexxExecTool(struct RexxPkt *Pkt)
  5733. {
  5734.     enum    {    ARG_EXECTOOL_CONSOLE,ARG_EXECTOOL_ASYNC,ARG_EXECTOOL_PORT,ARG_EXECTOOL_COMMAND };
  5735.  
  5736.     LONG     Error;
  5737.     UBYTE     CommandName[MAX_FILENAME_LENGTH],
  5738.          CommandArgs[MAX_FILENAME_LENGTH],
  5739.         *Index = Args[ARG_EXECTOOL_COMMAND];
  5740.     WORD     i;
  5741.     BYTE     Eaten = FALSE;
  5742.  
  5743.     while(*Index == ' ' || *Index == '\t')
  5744.         Index++;
  5745.  
  5746.     for(i = 0 ; Index[i] != ' ' && Index[i] != '\t' ; i++)
  5747.         CommandName[i] = Index[i];
  5748.  
  5749.     CommandName[i] = 0;
  5750.  
  5751.     Index += i;
  5752.  
  5753.     while(*Index == ' ' || *Index == '\t')
  5754.         Index++;
  5755.  
  5756.     if(Args[ARG_EXECTOOL_PORT])
  5757.         SPrintf(CommandArgs,"%s %s\n",Index,RexxPortName);
  5758.     else
  5759.         SPrintf(CommandArgs,"%s\n",Index);
  5760.  
  5761.     if(Args[ARG_EXECTOOL_ASYNC])
  5762.     {
  5763.         RexxPktCleanup(Pkt,NULL);
  5764.  
  5765.         Eaten = TRUE;
  5766.     }
  5767.  
  5768.     Error = SystemTags(CommandName,
  5769.         NP_Arguments,    CommandArgs,
  5770.         SYS_UserShell,    TRUE,
  5771.     TAG_DONE);
  5772.  
  5773.     if(!Eaten)
  5774.     {
  5775.         if(Error)
  5776.         {
  5777.             Results[0] = RC_ERROR;
  5778.             Results[1] = Error;
  5779.         }
  5780.  
  5781.         RexxPktCleanup(Pkt,NULL);
  5782.     }
  5783.  
  5784.     return(NULL);
  5785. }
  5786.